First model version

.gitattributes

@@ -25,3 +25,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zstandard filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+**.pt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+.ipynb_checkpoints
+.vscode
+flagged/
+resolute/
+.idea/

app.py

@@ -0,0 +1,47 @@
+from charset_normalizer import detect
+import numpy as np
+import gradio as gr
+import torch
+import torch.nn as nn
+import cv2
+import os
+from numpy import random
+from metadata.utils.utils import decodeImage
+from metadata.predictor_yolo_detector.detector_test import Detector
+from PIL import Image
+
+class ClientApp:
+    def __init__(self):
+        self.filename = "inputImage.jpg"
+        #modelPath = 'research/ssd_mobilenet_v1_coco_2017_11_17'
+        self.objectDetection = Detector(self.filename)
+
+
+
+
+clApp = ClientApp()
+
+def predict_image(input_img):
+
+    img = Image.fromarray(input_img)
+    img.save("./metadata/predictor_yolo_detector/inference/images/"+ clApp.filename)
+    resultant_img = clApp.objectDetection.detect_action()
+                                                            
+        
+    return resultant_img
+
+demo = gr.Blocks()
+
+with demo:
+    gr.Markdown(
+    """
+    <h1 align = "center"> Warehouse Apparel Detection </h1>
+    """)
+    
+    detect = gr.Interface(predict_image, 'image', 'image', examples=[
+        os.path.join(os.path.dirname(__file__), "images/image_1.jpg"),
+        os.path.join(os.path.dirname(__file__), "images/image_2.jpg"),
+        os.path.join(os.path.dirname(__file__), "images/image_3.jpg")
+        ])
+
+demo.launch()

metadata/dataset_utils/dataset_downloader.py

@@ -0,0 +1,21 @@
+import gdown
+from zipfile import ZipFile
+
+# Original Link :- https://drive.google.com/file/d/14QoqoZQLYnUmZgYblmFZ2u2eHo9yv2aA/view?usp=sharing
+url = 'https://drive.google.com/uc?id=14QoqoZQLYnUmZgYblmFZ2u2eHo9yv2aA'
+output = 'Fire_smoke.zip'
+
+gdown.download(url, output, quiet=False)
+
+# specifying the zip file name
+file_name = output
+
+# opening the zip file in READ mode
+with ZipFile(file_name, 'r') as zip:
+    # printing all the contents of the zip file
+    zip.printdir()
+
+    # extracting all the files
+    print('Extracting all the files now...')
+    zip.extractall()
+    print('Done!')

metadata/predictor_yolo_detector/best.pt

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

metadata/predictor_yolo_detector/detector_test.py

@@ -0,0 +1,176 @@
+import os
+import shutil
+import time
+from pathlib import Path
+
+import cv2
+import torch
+import torch.backends.cudnn as cudnn
+from numpy import random
+from PIL import Image
+
+from metadata.utils.utils import encodeImageIntoBase64
+
+import sys
+sys.path.insert(0, 'metadata/predictor_yolo_detector')
+
+from metadata.predictor_yolo_detector.models.experimental import attempt_load
+from metadata.predictor_yolo_detector.utils.datasets import LoadStreams, LoadImages
+from metadata.predictor_yolo_detector.utils.general import (
+    check_img_size, non_max_suppression, apply_classifier, scale_coords,
+    xyxy2xywh, plot_one_box, strip_optimizer, set_logging)
+from metadata.predictor_yolo_detector.utils.torch_utils import select_device, load_classifier, \
+    time_synchronized
+
+
+class Detector():
+    def __init__(self, filename):
+        self.weights = "./metadata/predictor_yolo_detector/best.pt"
+        self.conf = float(0.5)
+        self.source = "./metadata/predictor_yolo_detector/inference/images/"
+        self.img_size = int(416)
+        self.save_dir = "./metadata/predictor_yolo_detector/inference/output"
+        self.view_img = False
+        self.save_txt = False
+        self.device = 'cpu'
+        self.augment = True
+        self.agnostic_nms = True
+        self.conf_thres = float(0.5)
+        self.iou_thres = float(0.45)
+        self.classes = 0
+        self.save_conf = True
+        self.update = True
+        self.filename = filename
+
+    def detect(self, save_img=False):
+        out, source, weights, view_img, save_txt, imgsz = \
+            self.save_dir, self.source, self.weights, self.view_img, self.save_txt, self.img_size
+        webcam = source.isnumeric() or source.startswith(('rtsp://', 'rtmp://', 'http://')) or source.endswith('.txt')
+
+        # Initialize
+        set_logging()
+        device = select_device(self.device)
+        if os.path.exists(out):  # output dir
+            shutil.rmtree(out)  # delete dir
+        os.makedirs(out)  # make new dir
+        half = device.type != 'cpu'  # half precision only supported on CUDA
+
+        # Load model
+        model = attempt_load(weights, map_location=device)  # load FP32 model
+        imgsz = check_img_size(imgsz, s=model.stride.max())  # check img_size
+        if half:
+            model.half()  # to FP16
+
+        # Second-stage classifier
+        classify = False
+        if classify:
+            modelc = load_classifier(name='resnet101', n=2)  # initialize
+            modelc.load_state_dict(torch.load('weights/resnet101.pt', map_location=device)['model'])  # load weights
+            modelc.to(device).eval()
+
+        # Set Dataloader
+        vid_path, vid_writer = None, None
+        if webcam:
+            view_img = True
+            cudnn.benchmark = True  # set True to speed up constant image size inference
+            dataset = LoadStreams(source, img_size=imgsz)
+        else:
+            save_img = True
+            dataset = LoadImages(source, img_size=imgsz)
+
+        # Get names and colors
+        names = model.module.names if hasattr(model, 'module') else model.names
+        colors = [[random.randint(0, 255) for _ in range(3)] for _ in range(len(names))]
+
+        # Run inference
+        t0 = time.time()
+        img = torch.zeros((1, 3, imgsz, imgsz), device=device)  # init img
+        _ = model(img.half() if half else img) if device.type != 'cpu' else None  # run once
+        for path, img, im0s, vid_cap in dataset:
+            img = torch.from_numpy(img).to(device)
+            img = img.half() if half else img.float()  # uint8 to fp16/32
+            img /= 255.0  # 0 - 255 to 0.0 - 1.0
+            if img.ndimension() == 3:
+                img = img.unsqueeze(0)
+
+            # Inference
+            t1 = time_synchronized()
+            pred = model(img, augment=self.augment)[0]
+
+            # Apply NMS
+            pred = non_max_suppression(pred, self.conf_thres, self.iou_thres, classes=self.classes,
+                                       agnostic=self.agnostic_nms)
+            t2 = time_synchronized()
+
+            # Apply Classifier
+            if classify:
+                pred = apply_classifier(pred, modelc, img, im0s)
+
+            # Process detections
+            for i, det in enumerate(pred):  # detections per image
+                if webcam:  # batch_size >= 1
+                    p, s, im0 = path[i], '%g: ' % i, im0s[i].copy()
+                else:
+                    p, s, im0 = path, '', im0s
+
+                save_path = str(Path(out) / Path(p).name)
+                txt_path = str(Path(out) / Path(p).stem) + ('_%g' % dataset.frame if dataset.mode == 'video' else '')
+                s += '%gx%g ' % img.shape[2:]  # print string
+                gn = torch.tensor(im0.shape)[[1, 0, 1, 0]]  # normalization gain whwh
+                if det is not None and len(det):
+                    # Rescale boxes from img_size to im0 size
+                    det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round()
+
+                    # Print results
+                    for c in det[:, -1].unique():
+                        n = (det[:, -1] == c).sum()  # detections per class
+                        s += '%g %ss, ' % (n, names[int(c)])  # add to string
+
+                    # Write results
+                    for *xyxy, conf, cls in reversed(det):
+                        if save_txt:  # Write to file
+                            xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist()  # normalized xywh
+                            line = (cls, conf, *xywh) if self.save_conf else (cls, *xywh)  # label format
+                            with open(txt_path + '.txt', 'a') as f:
+                                f.write(('%g ' * len(line) + '\n') % line)
+
+                        if save_img or view_img:  # Add bbox to image
+                            label = '%s %.2f' % (names[int(cls)], conf)
+                            plot_one_box(xyxy, im0, label=label, color=colors[int(cls)], line_thickness=3)
+
+                # Print time (inference + NMS)
+                # print('%sDone. (%.3fs)' % (s, t2 - t1))
+                # detections = "Total No. of Cardboards:" + str(len(det))
+                # cv2.putText(img = im0, text = detections, org = (round(im0.shape[0]*0.08), round(im0.shape[1]*0.08)),fontFace = cv2.FONT_HERSHEY_DUPLEX, fontScale = 1.0,color = (0, 0, 255),thickness = 3)
+                im0 = cv2.cvtColor(im0, cv2.COLOR_RGB2BGR)
+                return im0
+        #         if save_img:
+        #             if dataset.mode == 'images':
+
+        #                 #im = im0[:, :, ::-1]
+        #                 im = Image.fromarray(im0)
+
+        #                 im.save("output.jpg")
+        #                 # cv2.imwrite(save_path, im0)
+        #             else:
+        #                 print("Video Processing Needed")
+
+
+        # if save_txt or save_img:
+        #     print('Results saved to %s' % Path(out))
+
+        # print('Done. (%.3fs)' % (time.time() - t0))
+
+        # return "Done"
+
+    def detect_action(self):
+        with torch.no_grad():
+            img = self.detect()
+        return img
+        # bgr_image = cv2.imread("output.jpg")
+        # im_rgb = cv2.cvtColor(bgr_image, cv2.COLOR_RGB2BGR)
+        # cv2.imwrite('color_img.jpg', im_rgb)
+        # opencodedbase64 = encodeImageIntoBase64("color_img.jpg")
+        # result = {"image": opencodedbase64.decode('utf-8')}
+        # return result
+

metadata/predictor_yolo_detector/models/common.py

@@ -0,0 +1,189 @@
+# This file contains modules common to various models
+
+import math
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+from metadata.predictor_yolo_detector.utils.datasets import letterbox
+from metadata.predictor_yolo_detector.utils.general import non_max_suppression, make_divisible, \
+    scale_coords
+
+
+def autopad(k, p=None):  # kernel, padding
+    # Pad to 'same'
+    if p is None:
+        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
+    return p
+
+
+def DWConv(c1, c2, k=1, s=1, act=True):
+    # Depthwise convolution
+    return Conv(c1, c2, k, s, g=math.gcd(c1, c2), act=act)
+
+
+class Conv(nn.Module):
+    # Standard convolution
+    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
+        super(Conv, self).__init__()
+        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
+        self.bn = nn.BatchNorm2d(c2)
+        self.act = nn.Hardswish() if act else nn.Identity()
+
+    def forward(self, x):
+        return self.act(self.bn(self.conv(x)))
+
+    def fuseforward(self, x):
+        return self.act(self.conv(x))
+
+
+class Bottleneck(nn.Module):
+    # Standard bottleneck
+    def __init__(self, c1, c2, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, shortcut, groups, expansion
+        super(Bottleneck, self).__init__()
+        c_ = int(c2 * e)  # hidden channels
+        self.cv1 = Conv(c1, c_, 1, 1)
+        self.cv2 = Conv(c_, c2, 3, 1, g=g)
+        self.add = shortcut and c1 == c2
+
+    def forward(self, x):
+        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
+
+
+class BottleneckCSP(nn.Module):
+    # CSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks
+    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
+        super(BottleneckCSP, self).__init__()
+        c_ = int(c2 * e)  # hidden channels
+        self.cv1 = Conv(c1, c_, 1, 1)
+        self.cv2 = nn.Conv2d(c1, c_, 1, 1, bias=False)
+        self.cv3 = nn.Conv2d(c_, c_, 1, 1, bias=False)
+        self.cv4 = Conv(2 * c_, c2, 1, 1)
+        self.bn = nn.BatchNorm2d(2 * c_)  # applied to cat(cv2, cv3)
+        self.act = nn.LeakyReLU(0.1, inplace=True)
+        self.m = nn.Sequential(*[Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)])
+
+    def forward(self, x):
+        y1 = self.cv3(self.m(self.cv1(x)))
+        y2 = self.cv2(x)
+        return self.cv4(self.act(self.bn(torch.cat((y1, y2), dim=1))))
+
+
+class SPP(nn.Module):
+    # Spatial pyramid pooling layer used in YOLOv3-SPP
+    def __init__(self, c1, c2, k=(5, 9, 13)):
+        super(SPP, self).__init__()
+        c_ = c1 // 2  # hidden channels
+        self.cv1 = Conv(c1, c_, 1, 1)
+        self.cv2 = Conv(c_ * (len(k) + 1), c2, 1, 1)
+        self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k])
+
+    def forward(self, x):
+        x = self.cv1(x)
+        return self.cv2(torch.cat([x] + [m(x) for m in self.m], 1))
+
+
+class Focus(nn.Module):
+    # Focus wh information into c-space
+    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
+        super(Focus, self).__init__()
+        self.conv = Conv(c1 * 4, c2, k, s, p, g, act)
+
+    def forward(self, x):  # x(b,c,w,h) -> y(b,4c,w/2,h/2)
+        return self.conv(torch.cat([x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]], 1))
+
+
+class Concat(nn.Module):
+    # Concatenate a list of tensors along dimension
+    def __init__(self, dimension=1):
+        super(Concat, self).__init__()
+        self.d = dimension
+
+    def forward(self, x):
+        return torch.cat(x, self.d)
+
+
+class NMS(nn.Module):
+    # Non-Maximum Suppression (NMS) module
+    conf = 0.25  # confidence threshold
+    iou = 0.45  # IoU threshold
+    classes = None  # (optional list) filter by class
+
+    def __init__(self):
+        super(NMS, self).__init__()
+
+    def forward(self, x):
+        return non_max_suppression(x[0], conf_thres=self.conf, iou_thres=self.iou, classes=self.classes)
+
+
+class autoShape(nn.Module):
+    # input-robust model wrapper for passing cv2/np/PIL/torch inputs. Includes preprocessing, inference and NMS
+    img_size = 640  # inference size (pixels)
+    conf = 0.25  # NMS confidence threshold
+    iou = 0.45  # NMS IoU threshold
+    classes = None  # (optional list) filter by class
+
+    def __init__(self, model):
+        super(autoShape, self).__init__()
+        self.model = model
+
+    def forward(self, x, size=640, augment=False, profile=False):
+        # supports inference from various sources. For height=720, width=1280, RGB images example inputs are:
+        #   opencv:     x = cv2.imread('image.jpg')[:,:,::-1]  # HWC BGR to RGB x(720,1280,3)
+        #   PIL:        x = Image.open('image.jpg')  # HWC x(720,1280,3)
+        #   numpy:      x = np.zeros((720,1280,3))  # HWC
+        #   torch:      x = torch.zeros(16,3,720,1280)  # BCHW
+        #   multiple:   x = [Image.open('image1.jpg'), Image.open('image2.jpg'), ...]  # list of images
+
+        p = next(self.model.parameters())  # for device and type
+        if isinstance(x, torch.Tensor):  # torch
+            return self.model(x.to(p.device).type_as(p), augment, profile)  # inference
+
+        # Pre-process
+        if not isinstance(x, list):
+            x = [x]
+        shape0, shape1 = [], []  # image and inference shapes
+        batch = range(len(x))  # batch size
+        for i in batch:
+            x[i] = np.array(x[i])  # to numpy
+            x[i] = x[i][:, :, :3] if x[i].ndim == 3 else np.tile(x[i][:, :, None], 3)  # enforce 3ch input
+            s = x[i].shape[:2]  # HWC
+            shape0.append(s)  # image shape
+            g = (size / max(s))  # gain
+            shape1.append([y * g for y in s])
+        shape1 = [make_divisible(x, int(self.stride.max())) for x in np.stack(shape1, 0).max(0)]  # inference shape
+        x = [letterbox(x[i], new_shape=shape1, auto=False)[0] for i in batch]  # pad
+        x = np.stack(x, 0) if batch[-1] else x[0][None]  # stack
+        x = np.ascontiguousarray(x.transpose((0, 3, 1, 2)))  # BHWC to BCHW
+        x = torch.from_numpy(x).to(p.device).type_as(p) / 255.  # uint8 to fp16/32
+
+        # Inference
+        x = self.model(x, augment, profile)  # forward
+        x = non_max_suppression(x[0], conf_thres=self.conf, iou_thres=self.iou, classes=self.classes)  # NMS
+
+        # Post-process
+        for i in batch:
+            if x[i] is not None:
+                x[i][:, :4] = scale_coords(shape1, x[i][:, :4], shape0[i])
+        return x
+
+
+class Flatten(nn.Module):
+    # Use after nn.AdaptiveAvgPool2d(1) to remove last 2 dimensions
+    @staticmethod
+    def forward(x):
+        return x.view(x.size(0), -1)
+
+
+class Classify(nn.Module):
+    # Classification head, i.e. x(b,c1,20,20) to x(b,c2)
+    def __init__(self, c1, c2, k=1, s=1, p=None, g=1):  # ch_in, ch_out, kernel, stride, padding, groups
+        super(Classify, self).__init__()
+        self.aap = nn.AdaptiveAvgPool2d(1)  # to x(b,c1,1,1)
+        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)  # to x(b,c2,1,1)
+        self.flat = Flatten()
+
+    def forward(self, x):
+        z = torch.cat([self.aap(y) for y in (x if isinstance(x, list) else [x])], 1)  # cat if list
+        return self.flat(self.conv(z))  # flatten to x(b,c2)

metadata/predictor_yolo_detector/models/custom_yolov5s.yaml

@@ -0,0 +1,48 @@
+# parameters
+nc: 2  # number of classes
+depth_multiple: 0.33  # model depth multiple
+width_multiple: 0.50  # layer channel multiple
+
+# anchors
+anchors:
+  - [ 10,13, 16,30, 33,23 ]  # P3/8
+  - [ 30,61, 62,45, 59,119 ]  # P4/16
+  - [ 116,90, 156,198, 373,326 ]  # P5/32
+
+# YOLOv5 backbone
+backbone:
+  # [from, number, module, args]
+  [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
+    [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
+    [ -1, 3, BottleneckCSP, [ 128 ] ],
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
+    [ -1, 9, BottleneckCSP, [ 256 ] ],
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
+    [ -1, 9, BottleneckCSP, [ 512 ] ],
+    [ -1, 1, Conv, [ 1024, 3, 2 ] ],  # 7-P5/32
+    [ -1, 1, SPP, [ 1024, [ 5, 9, 13 ] ] ],
+    [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 9
+  ]
+
+# YOLOv5 head
+head:
+  [ [ -1, 1, Conv, [ 512, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 13
+
+    [ -1, 1, Conv, [ 256, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
+    [ -1, 3, BottleneckCSP, [ 256, False ] ],  # 17 (P3/8-small)
+
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],
+    [ [ -1, 14 ], 1, Concat, [ 1 ] ],  # cat head P4
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 20 (P4/16-medium)
+
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],
+    [ [ -1, 10 ], 1, Concat, [ 1 ] ],  # cat head P5
+    [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 23 (P5/32-large)
+
+    [ [ 17, 20, 23 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5)
+  ]

metadata/predictor_yolo_detector/models/experimental.py

@@ -0,0 +1,152 @@
+# This file contains experimental modules
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+from metadata.predictor_yolo_detector.models.common import Conv, DWConv
+from metadata.predictor_yolo_detector.utils.google_utils import attempt_download
+
+
+class CrossConv(nn.Module):
+    # Cross Convolution Downsample
+    def __init__(self, c1, c2, k=3, s=1, g=1, e=1.0, shortcut=False):
+        # ch_in, ch_out, kernel, stride, groups, expansion, shortcut
+        super(CrossConv, self).__init__()
+        c_ = int(c2 * e)  # hidden channels
+        self.cv1 = Conv(c1, c_, (1, k), (1, s))
+        self.cv2 = Conv(c_, c2, (k, 1), (s, 1), g=g)
+        self.add = shortcut and c1 == c2
+
+    def forward(self, x):
+        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
+
+
+class C3(nn.Module):
+    # Cross Convolution CSP
+    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
+        super(C3, self).__init__()
+        c_ = int(c2 * e)  # hidden channels
+        self.cv1 = Conv(c1, c_, 1, 1)
+        self.cv2 = nn.Conv2d(c1, c_, 1, 1, bias=False)
+        self.cv3 = nn.Conv2d(c_, c_, 1, 1, bias=False)
+        self.cv4 = Conv(2 * c_, c2, 1, 1)
+        self.bn = nn.BatchNorm2d(2 * c_)  # applied to cat(cv2, cv3)
+        self.act = nn.LeakyReLU(0.1, inplace=True)
+        self.m = nn.Sequential(*[CrossConv(c_, c_, 3, 1, g, 1.0, shortcut) for _ in range(n)])
+
+    def forward(self, x):
+        y1 = self.cv3(self.m(self.cv1(x)))
+        y2 = self.cv2(x)
+        return self.cv4(self.act(self.bn(torch.cat((y1, y2), dim=1))))
+
+
+class Sum(nn.Module):
+    # Weighted sum of 2 or more layers https://arxiv.org/abs/1911.09070
+    def __init__(self, n, weight=False):  # n: number of inputs
+        super(Sum, self).__init__()
+        self.weight = weight  # apply weights boolean
+        self.iter = range(n - 1)  # iter object
+        if weight:
+            self.w = nn.Parameter(-torch.arange(1., n) / 2, requires_grad=True)  # layer weights
+
+    def forward(self, x):
+        y = x[0]  # no weight
+        if self.weight:
+            w = torch.sigmoid(self.w) * 2
+            for i in self.iter:
+                y = y + x[i + 1] * w[i]
+        else:
+            for i in self.iter:
+                y = y + x[i + 1]
+        return y
+
+
+class GhostConv(nn.Module):
+    # Ghost Convolution https://github.com/huawei-noah/ghostnet
+    def __init__(self, c1, c2, k=1, s=1, g=1, act=True):  # ch_in, ch_out, kernel, stride, groups
+        super(GhostConv, self).__init__()
+        c_ = c2 // 2  # hidden channels
+        self.cv1 = Conv(c1, c_, k, s, None, g, act)
+        self.cv2 = Conv(c_, c_, 5, 1, None, c_, act)
+
+    def forward(self, x):
+        y = self.cv1(x)
+        return torch.cat([y, self.cv2(y)], 1)
+
+
+class GhostBottleneck(nn.Module):
+    # Ghost Bottleneck https://github.com/huawei-noah/ghostnet
+    def __init__(self, c1, c2, k, s):
+        super(GhostBottleneck, self).__init__()
+        c_ = c2 // 2
+        self.conv = nn.Sequential(GhostConv(c1, c_, 1, 1),  # pw
+                                  DWConv(c_, c_, k, s, act=False) if s == 2 else nn.Identity(),  # dw
+                                  GhostConv(c_, c2, 1, 1, act=False))  # pw-linear
+        self.shortcut = nn.Sequential(DWConv(c1, c1, k, s, act=False),
+                                      Conv(c1, c2, 1, 1, act=False)) if s == 2 else nn.Identity()
+
+    def forward(self, x):
+        return self.conv(x) + self.shortcut(x)
+
+
+class MixConv2d(nn.Module):
+    # Mixed Depthwise Conv https://arxiv.org/abs/1907.09595
+    def __init__(self, c1, c2, k=(1, 3), s=1, equal_ch=True):
+        super(MixConv2d, self).__init__()
+        groups = len(k)
+        if equal_ch:  # equal c_ per group
+            i = torch.linspace(0, groups - 1E-6, c2).floor()  # c2 indices
+            c_ = [(i == g).sum() for g in range(groups)]  # intermediate channels
+        else:  # equal weight.numel() per group
+            b = [c2] + [0] * groups
+            a = np.eye(groups + 1, groups, k=-1)
+            a -= np.roll(a, 1, axis=1)
+            a *= np.array(k) ** 2
+            a[0] = 1
+            c_ = np.linalg.lstsq(a, b, rcond=None)[0].round()  # solve for equal weight indices, ax = b
+
+        self.m = nn.ModuleList([nn.Conv2d(c1, int(c_[g]), k[g], s, k[g] // 2, bias=False) for g in range(groups)])
+        self.bn = nn.BatchNorm2d(c2)
+        self.act = nn.LeakyReLU(0.1, inplace=True)
+
+    def forward(self, x):
+        return x + self.act(self.bn(torch.cat([m(x) for m in self.m], 1)))
+
+
+class Ensemble(nn.ModuleList):
+    # Ensemble of models
+    def __init__(self):
+        super(Ensemble, self).__init__()
+
+    def forward(self, x, augment=False):
+        y = []
+        for module in self:
+            y.append(module(x, augment)[0])
+        # y = torch.stack(y).max(0)[0]  # max ensemble
+        # y = torch.cat(y, 1)  # nms ensemble
+        y = torch.stack(y).mean(0)  # mean ensemble
+        return y, None  # inference, train output
+
+
+def attempt_load(weights, map_location=None):
+    # Loads an ensemble of models weights=[a,b,c] or a single model weights=[a] or weights=a
+    model = Ensemble()
+    for w in weights if isinstance(weights, list) else [weights]:
+        attempt_download(w)
+        model.append(torch.load(w, map_location=map_location)['model'].float().fuse().eval())  # load FP32 model
+
+    # Compatibility updates
+    for m in model.modules():
+        if type(m) in [nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6]:
+            m.inplace = True  # pytorch 1.7.0 compatibility
+        elif type(m) is Conv:
+            m._non_persistent_buffers_set = set()  # pytorch 1.6.0 compatibility
+
+    if len(model) == 1:
+        return model[-1]  # return model
+    else:
+        print('Ensemble created with %s\n' % weights)
+        for k in ['names', 'stride']:
+            setattr(model, k, getattr(model[-1], k))
+        return model  # return ensemble

metadata/predictor_yolo_detector/models/export.py

@@ -0,0 +1,94 @@
+"""Exports a YOLOv5 *.pt model to ONNX and TorchScript formats
+
+Usage:
+    $ export PYTHONPATH="$PWD" && python models/export.py --weights ./weights/yolov5s.pt --img 640 --batch 1
+"""
+
+import argparse
+import sys
+import time
+
+sys.path.append('./')  # to run '$ python *.py' files in subdirectories
+
+import torch
+import torch.nn as nn
+
+from metadata.predictor_yolo_detector.models import common
+from metadata.predictor_yolo_detector.models.experimental import attempt_load
+from metadata.predictor_yolo_detector.utils.activations import Hardswish
+from metadata.predictor_yolo_detector.utils.general import set_logging, check_img_size
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--weights', type=str, default='./yolov5s.pt', help='weights path')  # from yolov5/models/
+    parser.add_argument('--img-size', nargs='+', type=int, default=[640, 640], help='image size')  # height, width
+    parser.add_argument('--batch-size', type=int, default=1, help='batch size')
+    opt = parser.parse_args()
+    opt.img_size *= 2 if len(opt.img_size) == 1 else 1  # expand
+    print(opt)
+    set_logging()
+    t = time.time()
+
+    # Load PyTorch model
+    model = attempt_load(opt.weights, map_location=torch.device('cpu'))  # load FP32 model
+    labels = model.names
+
+    # Checks
+    gs = int(max(model.stride))  # grid size (max stride)
+    opt.img_size = [check_img_size(x, gs) for x in opt.img_size]  # verify img_size are gs-multiples
+
+    # Input
+    img = torch.zeros(opt.batch_size, 3, *opt.img_size)  # image size(1,3,320,192) iDetection
+
+    # Update model
+    for k, m in model.named_modules():
+        m._non_persistent_buffers_set = set()  # pytorch 1.6.0 compatibility
+        if isinstance(m, common.Conv) and isinstance(m.act, nn.Hardswish):
+            m.act = Hardswish()  # assign activation
+        # if isinstance(m, models.yolo.Detect):
+        #     m.forward = m.forward_export  # assign forward (optional)
+    model.model[-1].export = True  # set Detect() layer export=True
+    y = model(img)  # dry run
+
+    # TorchScript export
+    try:
+        print('\nStarting TorchScript export with torch %s...' % torch.__version__)
+        f = opt.weights.replace('.pt', '.torchscript.pt')  # filename
+        ts = torch.jit.trace(model, img)
+        ts.save(f)
+        print('TorchScript export success, saved as %s' % f)
+    except Exception as e:
+        print('TorchScript export failure: %s' % e)
+
+    # ONNX export
+    try:
+        import onnx
+
+        print('\nStarting ONNX export with onnx %s...' % onnx.__version__)
+        f = opt.weights.replace('.pt', '.onnx')  # filename
+        torch.onnx.export(model, img, f, verbose=False, opset_version=12, input_names=['images'],
+                          output_names=['classes', 'boxes'] if y is None else ['output'])
+
+        # Checks
+        onnx_model = onnx.load(f)  # load onnx model
+        onnx.checker.check_model(onnx_model)  # check onnx model
+        # print(onnx.helper.printable_graph(onnx_model.graph))  # print a human readable model
+        print('ONNX export success, saved as %s' % f)
+    except Exception as e:
+        print('ONNX export failure: %s' % e)
+
+    # CoreML export
+    try:
+        import coremltools as ct
+
+        print('\nStarting CoreML export with coremltools %s...' % ct.__version__)
+        # convert model from torchscript and apply pixel scaling as per detect.py
+        model = ct.convert(ts, inputs=[ct.ImageType(name='image', shape=img.shape, scale=1 / 255.0, bias=[0, 0, 0])])
+        f = opt.weights.replace('.pt', '.mlmodel')  # filename
+        model.save(f)
+        print('CoreML export success, saved as %s' % f)
+    except Exception as e:
+        print('CoreML export failure: %s' % e)
+
+    # Finish
+    print('\nExport complete (%.2fs). Visualize with https://github.com/lutzroeder/netron.' % (time.time() - t))

metadata/predictor_yolo_detector/models/hub/yolov3-spp.yaml

@@ -0,0 +1,51 @@
+# parameters
+nc: 80  # number of classes
+depth_multiple: 1.0  # model depth multiple
+width_multiple: 1.0  # layer channel multiple
+
+# anchors
+anchors:
+  - [ 10,13, 16,30, 33,23 ]  # P3/8
+  - [ 30,61, 62,45, 59,119 ]  # P4/16
+  - [ 116,90, 156,198, 373,326 ]  # P5/32
+
+# darknet53 backbone
+backbone:
+  # [from, number, module, args]
+  [ [ -1, 1, Conv, [ 32, 3, 1 ] ],  # 0
+    [ -1, 1, Conv, [ 64, 3, 2 ] ],  # 1-P1/2
+    [ -1, 1, Bottleneck, [ 64 ] ],
+    [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 3-P2/4
+    [ -1, 2, Bottleneck, [ 128 ] ],
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 5-P3/8
+    [ -1, 8, Bottleneck, [ 256 ] ],
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 7-P4/16
+    [ -1, 8, Bottleneck, [ 512 ] ],
+    [ -1, 1, Conv, [ 1024, 3, 2 ] ], # 9-P5/32
+    [ -1, 4, Bottleneck, [ 1024 ] ],  # 10
+  ]
+
+# YOLOv3-SPP head
+head:
+  [ [ -1, 1, Bottleneck, [ 1024, False ] ],
+    [ -1, 1, SPP, [ 512, [ 5, 9, 13 ] ] ],
+    [ -1, 1, Conv, [ 1024, 3, 1 ] ],
+    [ -1, 1, Conv, [ 512, 1, 1 ] ],
+    [ -1, 1, Conv, [ 1024, 3, 1 ] ],  # 15 (P5/32-large)
+
+    [ -2, 1, Conv, [ 256, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 8 ], 1, Concat, [ 1 ] ],  # cat backbone P4
+    [ -1, 1, Bottleneck, [ 512, False ] ],
+    [ -1, 1, Bottleneck, [ 512, False ] ],
+    [ -1, 1, Conv, [ 256, 1, 1 ] ],
+    [ -1, 1, Conv, [ 512, 3, 1 ] ],  # 22 (P4/16-medium)
+
+    [ -2, 1, Conv, [ 128, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P3
+    [ -1, 1, Bottleneck, [ 256, False ] ],
+    [ -1, 2, Bottleneck, [ 256, False ] ],  # 27 (P3/8-small)
+
+    [ [ 27, 22, 15 ], 1, Detect, [ nc, anchors ] ],   # Detect(P3, P4, P5)
+  ]

metadata/predictor_yolo_detector/models/hub/yolov5-fpn.yaml

@@ -0,0 +1,42 @@
+# parameters
+nc: 80  # number of classes
+depth_multiple: 1.0  # model depth multiple
+width_multiple: 1.0  # layer channel multiple
+
+# anchors
+anchors:
+  - [ 10,13, 16,30, 33,23 ]  # P3/8
+  - [ 30,61, 62,45, 59,119 ]  # P4/16
+  - [ 116,90, 156,198, 373,326 ]  # P5/32
+
+# YOLOv5 backbone
+backbone:
+  # [from, number, module, args]
+  [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
+    [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
+    [ -1, 3, Bottleneck, [ 128 ] ],
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
+    [ -1, 9, BottleneckCSP, [ 256 ] ],
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
+    [ -1, 9, BottleneckCSP, [ 512 ] ],
+    [ -1, 1, Conv, [ 1024, 3, 2 ] ], # 7-P5/32
+    [ -1, 1, SPP, [ 1024, [ 5, 9, 13 ] ] ],
+    [ -1, 6, BottleneckCSP, [ 1024 ] ],  # 9
+  ]
+
+# YOLOv5 FPN head
+head:
+  [ [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 10 (P5/32-large)
+
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
+    [ -1, 1, Conv, [ 512, 1, 1 ] ],
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 14 (P4/16-medium)
+
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
+    [ -1, 1, Conv, [ 256, 1, 1 ] ],
+    [ -1, 3, BottleneckCSP, [ 256, False ] ],  # 18 (P3/8-small)
+
+    [ [ 18, 14, 10 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5)
+  ]

metadata/predictor_yolo_detector/models/hub/yolov5-panet.yaml

@@ -0,0 +1,48 @@
+# parameters
+nc: 80  # number of classes
+depth_multiple: 1.0  # model depth multiple
+width_multiple: 1.0  # layer channel multiple
+
+# anchors
+anchors:
+  - [ 116,90, 156,198, 373,326 ]  # P5/32
+  - [ 30,61, 62,45, 59,119 ]  # P4/16
+  - [ 10,13, 16,30, 33,23 ]  # P3/8
+
+# YOLOv5 backbone
+backbone:
+  # [from, number, module, args]
+  [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
+    [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
+    [ -1, 3, BottleneckCSP, [ 128 ] ],
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
+    [ -1, 9, BottleneckCSP, [ 256 ] ],
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
+    [ -1, 9, BottleneckCSP, [ 512 ] ],
+    [ -1, 1, Conv, [ 1024, 3, 2 ] ], # 7-P5/32
+    [ -1, 1, SPP, [ 1024, [ 5, 9, 13 ] ] ],
+    [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 9
+  ]
+
+# YOLOv5 PANet head
+head:
+  [ [ -1, 1, Conv, [ 512, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 13
+
+    [ -1, 1, Conv, [ 256, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
+    [ -1, 3, BottleneckCSP, [ 256, False ] ],  # 17 (P3/8-small)
+
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],
+    [ [ -1, 14 ], 1, Concat, [ 1 ] ],  # cat head P4
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 20 (P4/16-medium)
+
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],
+    [ [ -1, 10 ], 1, Concat, [ 1 ] ],  # cat head P5
+    [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 23 (P5/32-large)
+
+    [ [ 17, 20, 23 ], 1, Detect, [ nc, anchors ] ],  # Detect(P5, P4, P3)
+  ]

metadata/predictor_yolo_detector/models/yolo.py

@@ -0,0 +1,283 @@
+import argparse
+import logging
+import sys
+from copy import deepcopy
+from pathlib import Path
+
+import math
+
+sys.path.append('./')  # to run '$ python *.py' files in subdirectories
+logger = logging.getLogger(__name__)
+
+import torch
+import torch.nn as nn
+
+from models.common import Conv, Bottleneck, SPP, DWConv, Focus, BottleneckCSP, Concat, NMS, autoShape
+from models.experimental import MixConv2d, CrossConv, C3
+from utils.general import check_anchor_order, make_divisible, check_file, set_logging
+from utils.torch_utils import time_synchronized, fuse_conv_and_bn, model_info, scale_img, initialize_weights, \
+    select_device, copy_attr
+
+
+class Detect(nn.Module):
+    stride = None  # strides computed during build
+    export = False  # onnx export
+
+    def __init__(self, nc=80, anchors=(), ch=()):  # detection layer
+        super(Detect, self).__init__()
+        self.nc = nc  # number of classes
+        self.no = nc + 5  # number of outputs per anchor
+        self.nl = len(anchors)  # number of detection layers
+        self.na = len(anchors[0]) // 2  # number of anchors
+        self.grid = [torch.zeros(1)] * self.nl  # init grid
+        a = torch.tensor(anchors).float().view(self.nl, -1, 2)
+        self.register_buffer('anchors', a)  # shape(nl,na,2)
+        self.register_buffer('anchor_grid', a.clone().view(self.nl, 1, -1, 1, 1, 2))  # shape(nl,1,na,1,1,2)
+        self.m = nn.ModuleList(nn.Conv2d(x, self.no * self.na, 1) for x in ch)  # output conv
+
+    def forward(self, x):
+        # x = x.copy()  # for profiling
+        z = []  # inference output
+        self.training |= self.export
+        for i in range(self.nl):
+            x[i] = self.m[i](x[i])  # conv
+            bs, _, ny, nx = x[i].shape  # x(bs,255,20,20) to x(bs,3,20,20,85)
+            x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()
+
+            if not self.training:  # inference
+                if self.grid[i].shape[2:4] != x[i].shape[2:4]:
+                    self.grid[i] = self._make_grid(nx, ny).to(x[i].device)
+
+                y = x[i].sigmoid()
+                y[..., 0:2] = (y[..., 0:2] * 2. - 0.5 + self.grid[i].to(x[i].device)) * self.stride[i]  # xy
+                y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i]  # wh
+                z.append(y.view(bs, -1, self.no))
+
+        return x if self.training else (torch.cat(z, 1), x)
+
+    @staticmethod
+    def _make_grid(nx=20, ny=20):
+        yv, xv = torch.meshgrid([torch.arange(ny), torch.arange(nx)])
+        return torch.stack((xv, yv), 2).view((1, 1, ny, nx, 2)).float()
+
+
+class Model(nn.Module):
+    def __init__(self, cfg='yolov5s.yaml', ch=3, nc=None):  # model, input channels, number of classes
+        super(Model, self).__init__()
+        if isinstance(cfg, dict):
+            self.yaml = cfg  # model dict
+        else:  # is *.yaml
+            import yaml  # for torch hub
+            self.yaml_file = Path(cfg).name
+            with open(cfg) as f:
+                self.yaml = yaml.load(f, Loader=yaml.FullLoader)  # model dict
+
+        # Define model
+        if nc and nc != self.yaml['nc']:
+            print('Overriding model.yaml nc=%g with nc=%g' % (self.yaml['nc'], nc))
+            self.yaml['nc'] = nc  # override yaml value
+        self.model, self.save = parse_model(deepcopy(self.yaml), ch=[ch])  # model, savelist, ch_out
+        # print([x.shape for x in self.forward(torch.zeros(1, ch, 64, 64))])
+
+        # Build strides, anchors
+        m = self.model[-1]  # Detect()
+        if isinstance(m, Detect):
+            s = 128  # 2x min stride
+            m.stride = torch.tensor([s / x.shape[-2] for x in self.forward(torch.zeros(1, ch, s, s))])  # forward
+            m.anchors /= m.stride.view(-1, 1, 1)
+            check_anchor_order(m)
+            self.stride = m.stride
+            self._initialize_biases()  # only run once
+            # print('Strides: %s' % m.stride.tolist())
+
+        # Init weights, biases
+        initialize_weights(self)
+        self.info()
+        print('')
+
+    def forward(self, x, augment=False, profile=False):
+        if augment:
+            img_size = x.shape[-2:]  # height, width
+            s = [1, 0.83, 0.67]  # scales
+            f = [None, 3, None]  # flips (2-ud, 3-lr)
+            y = []  # outputs
+            for si, fi in zip(s, f):
+                xi = scale_img(x.flip(fi) if fi else x, si)
+                yi = self.forward_once(xi)[0]  # forward
+                # cv2.imwrite('img%g.jpg' % s, 255 * xi[0].numpy().transpose((1, 2, 0))[:, :, ::-1])  # save
+                yi[..., :4] /= si  # de-scale
+                if fi == 2:
+                    yi[..., 1] = img_size[0] - yi[..., 1]  # de-flip ud
+                elif fi == 3:
+                    yi[..., 0] = img_size[1] - yi[..., 0]  # de-flip lr
+                y.append(yi)
+            return torch.cat(y, 1), None  # augmented inference, train
+        else:
+            return self.forward_once(x, profile)  # single-scale inference, train
+
+    def forward_once(self, x, profile=False):
+        y, dt = [], []  # outputs
+        for m in self.model:
+            if m.f != -1:  # if not from previous layer
+                x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f]  # from earlier layers
+
+            if profile:
+                try:
+                    import thop
+                    o = thop.profile(m, inputs=(x,), verbose=False)[0] / 1E9 * 2  # FLOPS
+                except:
+                    o = 0
+                t = time_synchronized()
+                for _ in range(10):
+                    _ = m(x)
+                dt.append((time_synchronized() - t) * 100)
+                print('%10.1f%10.0f%10.1fms %-40s' % (o, m.np, dt[-1], m.type))
+
+            x = m(x)  # run
+            y.append(x if m.i in self.save else None)  # save output
+
+        if profile:
+            print('%.1fms total' % sum(dt))
+        return x
+
+    def _initialize_biases(self, cf=None):  # initialize biases into Detect(), cf is class frequency
+        # https://arxiv.org/abs/1708.02002 section 3.3
+        # cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1.
+        m = self.model[-1]  # Detect() module
+        for mi, s in zip(m.m, m.stride):  # from
+            b = mi.bias.view(m.na, -1)  # conv.bias(255) to (3,85)
+            b[:, 4] += math.log(8 / (640 / s) ** 2)  # obj (8 objects per 640 image)
+            b[:, 5:] += math.log(0.6 / (m.nc - 0.99)) if cf is None else torch.log(cf / cf.sum())  # cls
+            mi.bias = torch.nn.Parameter(b.view(-1), requires_grad=True)
+
+    def _print_biases(self):
+        m = self.model[-1]  # Detect() module
+        for mi in m.m:  # from
+            b = mi.bias.detach().view(m.na, -1).T  # conv.bias(255) to (3,85)
+            print(('%6g Conv2d.bias:' + '%10.3g' * 6) % (mi.weight.shape[1], *b[:5].mean(1).tolist(), b[5:].mean()))
+
+    # def _print_weights(self):
+    #     for m in self.model.modules():
+    #         if type(m) is Bottleneck:
+    #             print('%10.3g' % (m.w.detach().sigmoid() * 2))  # shortcut weights
+
+    def fuse(self):  # fuse model Conv2d() + BatchNorm2d() layers
+        # print('Fusing layers... ')
+        for m in self.model.modules():
+            if type(m) is Conv and hasattr(m, 'bn'):
+                m.conv = fuse_conv_and_bn(m.conv, m.bn)  # update conv
+                delattr(m, 'bn')  # remove batchnorm
+                m.forward = m.fuseforward  # update forward
+        self.info()
+        return self
+
+    def nms(self, mode=True):  # add or remove NMS module
+        present = type(self.model[-1]) is NMS  # last layer is NMS
+        if mode and not present:
+            print('Adding NMS... ')
+            m = NMS()  # module
+            m.f = -1  # from
+            m.i = self.model[-1].i + 1  # index
+            self.model.add_module(name='%s' % m.i, module=m)  # add
+            self.eval()
+        elif not mode and present:
+            print('Removing NMS... ')
+            self.model = self.model[:-1]  # remove
+        return self
+
+    def autoshape(self):  # add autoShape module
+        print('Adding autoShape... ')
+        m = autoShape(self)  # wrap model
+        copy_attr(m, self, include=('yaml', 'nc', 'hyp', 'names', 'stride'), exclude=())  # copy attributes
+        return m
+
+    def info(self, verbose=False):  # print model information
+        model_info(self, verbose)
+
+
+def parse_model(d, ch):  # model_dict, input_channels(3)
+    logger.info('\n%3s%18s%3s%10s  %-40s%-30s' % ('', 'from', 'n', 'params', 'module', 'arguments'))
+    anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple']
+    na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors  # number of anchors
+    no = na * (nc + 5)  # number of outputs = anchors * (classes + 5)
+
+    layers, save, c2 = [], [], ch[-1]  # layers, savelist, ch out
+    for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):  # from, number, module, args
+        m = eval(m) if isinstance(m, str) else m  # eval strings
+        for j, a in enumerate(args):
+            try:
+                args[j] = eval(a) if isinstance(a, str) else a  # eval strings
+            except:
+                pass
+
+        n = max(round(n * gd), 1) if n > 1 else n  # depth gain
+        if m in [Conv, Bottleneck, SPP, DWConv, MixConv2d, Focus, CrossConv, BottleneckCSP, C3]:
+            c1, c2 = ch[f], args[0]
+
+            # Normal
+            # if i > 0 and args[0] != no:  # channel expansion factor
+            #     ex = 1.75  # exponential (default 2.0)
+            #     e = math.log(c2 / ch[1]) / math.log(2)
+            #     c2 = int(ch[1] * ex ** e)
+            # if m != Focus:
+
+            c2 = make_divisible(c2 * gw, 8) if c2 != no else c2
+
+            # Experimental
+            # if i > 0 and args[0] != no:  # channel expansion factor
+            #     ex = 1 + gw  # exponential (default 2.0)
+            #     ch1 = 32  # ch[1]
+            #     e = math.log(c2 / ch1) / math.log(2)  # level 1-n
+            #     c2 = int(ch1 * ex ** e)
+            # if m != Focus:
+            #     c2 = make_divisible(c2, 8) if c2 != no else c2
+
+            args = [c1, c2, *args[1:]]
+            if m in [BottleneckCSP, C3]:
+                args.insert(2, n)
+                n = 1
+        elif m is nn.BatchNorm2d:
+            args = [ch[f]]
+        elif m is Concat:
+            c2 = sum([ch[-1 if x == -1 else x + 1] for x in f])
+        elif m is Detect:
+            args.append([ch[x + 1] for x in f])
+            if isinstance(args[1], int):  # number of anchors
+                args[1] = [list(range(args[1] * 2))] * len(f)
+        else:
+            c2 = ch[f]
+
+        m_ = nn.Sequential(*[m(*args) for _ in range(n)]) if n > 1 else m(*args)  # module
+        t = str(m)[8:-2].replace('__main__.', '')  # module type
+        np = sum([x.numel() for x in m_.parameters()])  # number params
+        m_.i, m_.f, m_.type, m_.np = i, f, t, np  # attach index, 'from' index, type, number params
+        logger.info('%3s%18s%3s%10.0f  %-40s%-30s' % (i, f, n, np, t, args))  # print
+        save.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1)  # append to savelist
+        layers.append(m_)
+        ch.append(c2)
+    return nn.Sequential(*layers), sorted(save)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--cfg', type=str, default='yolov5s.yaml', help='model.yaml')
+    parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
+    opt = parser.parse_args()
+    opt.cfg = check_file(opt.cfg)  # check file
+    set_logging()
+    device = select_device(opt.device)
+
+    # Create model
+    model = Model(opt.cfg).to(device)
+    model.train()
+
+    # Profile
+    # img = torch.rand(8 if torch.cuda.is_available() else 1, 3, 640, 640).to(device)
+    # y = model(img, profile=True)
+
+    # Tensorboard
+    # from torch.utils.tensorboard import SummaryWriter
+    # tb_writer = SummaryWriter()
+    # print("Run 'tensorboard --logdir=models/runs' to view tensorboard at http://localhost:6006/")
+    # tb_writer.add_graph(model.model, img)  # add model to tensorboard
+    # tb_writer.add_image('test', img[0], dataformats='CWH')  # add model to tensorboard

metadata/predictor_yolo_detector/models/yolov5l.yaml

@@ -0,0 +1,48 @@
+# parameters
+nc: 80  # number of classes
+depth_multiple: 1.0  # model depth multiple
+width_multiple: 1.0  # layer channel multiple
+
+# anchors
+anchors:
+  - [ 10,13, 16,30, 33,23 ]  # P3/8
+  - [ 30,61, 62,45, 59,119 ]  # P4/16
+  - [ 116,90, 156,198, 373,326 ]  # P5/32
+
+# YOLOv5 backbone
+backbone:
+  # [from, number, module, args]
+  [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
+    [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
+    [ -1, 3, BottleneckCSP, [ 128 ] ],
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
+    [ -1, 9, BottleneckCSP, [ 256 ] ],
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
+    [ -1, 9, BottleneckCSP, [ 512 ] ],
+    [ -1, 1, Conv, [ 1024, 3, 2 ] ],  # 7-P5/32
+    [ -1, 1, SPP, [ 1024, [ 5, 9, 13 ] ] ],
+    [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 9
+  ]
+
+# YOLOv5 head
+head:
+  [ [ -1, 1, Conv, [ 512, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 13
+
+    [ -1, 1, Conv, [ 256, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
+    [ -1, 3, BottleneckCSP, [ 256, False ] ],  # 17 (P3/8-small)
+
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],
+    [ [ -1, 14 ], 1, Concat, [ 1 ] ],  # cat head P4
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 20 (P4/16-medium)
+
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],
+    [ [ -1, 10 ], 1, Concat, [ 1 ] ],  # cat head P5
+    [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 23 (P5/32-large)
+
+    [ [ 17, 20, 23 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5)
+  ]

metadata/predictor_yolo_detector/models/yolov5m.yaml

@@ -0,0 +1,48 @@
+# parameters
+nc: 80  # number of classes
+depth_multiple: 0.67  # model depth multiple
+width_multiple: 0.75  # layer channel multiple
+
+# anchors
+anchors:
+  - [ 10,13, 16,30, 33,23 ]  # P3/8
+  - [ 30,61, 62,45, 59,119 ]  # P4/16
+  - [ 116,90, 156,198, 373,326 ]  # P5/32
+
+# YOLOv5 backbone
+backbone:
+  # [from, number, module, args]
+  [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
+    [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
+    [ -1, 3, BottleneckCSP, [ 128 ] ],
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
+    [ -1, 9, BottleneckCSP, [ 256 ] ],
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
+    [ -1, 9, BottleneckCSP, [ 512 ] ],
+    [ -1, 1, Conv, [ 1024, 3, 2 ] ],  # 7-P5/32
+    [ -1, 1, SPP, [ 1024, [ 5, 9, 13 ] ] ],
+    [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 9
+  ]
+
+# YOLOv5 head
+head:
+  [ [ -1, 1, Conv, [ 512, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 13
+
+    [ -1, 1, Conv, [ 256, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
+    [ -1, 3, BottleneckCSP, [ 256, False ] ],  # 17 (P3/8-small)
+
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],
+    [ [ -1, 14 ], 1, Concat, [ 1 ] ],  # cat head P4
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 20 (P4/16-medium)
+
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],
+    [ [ -1, 10 ], 1, Concat, [ 1 ] ],  # cat head P5
+    [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 23 (P5/32-large)
+
+    [ [ 17, 20, 23 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5)
+  ]

metadata/predictor_yolo_detector/models/yolov5s.yaml

@@ -0,0 +1,48 @@
+# parameters
+nc: 80  # number of classes
+depth_multiple: 0.33  # model depth multiple
+width_multiple: 0.50  # layer channel multiple
+
+# anchors
+anchors:
+  - [ 10,13, 16,30, 33,23 ]  # P3/8
+  - [ 30,61, 62,45, 59,119 ]  # P4/16
+  - [ 116,90, 156,198, 373,326 ]  # P5/32
+
+# YOLOv5 backbone
+backbone:
+  # [from, number, module, args]
+  [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
+    [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
+    [ -1, 3, BottleneckCSP, [ 128 ] ],
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
+    [ -1, 9, BottleneckCSP, [ 256 ] ],
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
+    [ -1, 9, BottleneckCSP, [ 512 ] ],
+    [ -1, 1, Conv, [ 1024, 3, 2 ] ],  # 7-P5/32
+    [ -1, 1, SPP, [ 1024, [ 5, 9, 13 ] ] ],
+    [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 9
+  ]
+
+# YOLOv5 head
+head:
+  [ [ -1, 1, Conv, [ 512, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 13
+
+    [ -1, 1, Conv, [ 256, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
+    [ -1, 3, BottleneckCSP, [ 256, False ] ],  # 17 (P3/8-small)
+
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],
+    [ [ -1, 14 ], 1, Concat, [ 1 ] ],  # cat head P4
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 20 (P4/16-medium)
+
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],
+    [ [ -1, 10 ], 1, Concat, [ 1 ] ],  # cat head P5
+    [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 23 (P5/32-large)
+
+    [ [ 17, 20, 23 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5)
+  ]

metadata/predictor_yolo_detector/models/yolov5x.yaml

@@ -0,0 +1,48 @@
+# parameters
+nc: 80  # number of classes
+depth_multiple: 1.33  # model depth multiple
+width_multiple: 1.25  # layer channel multiple
+
+# anchors
+anchors:
+  - [ 10,13, 16,30, 33,23 ]  # P3/8
+  - [ 30,61, 62,45, 59,119 ]  # P4/16
+  - [ 116,90, 156,198, 373,326 ]  # P5/32
+
+# YOLOv5 backbone
+backbone:
+  # [from, number, module, args]
+  [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
+    [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
+    [ -1, 3, BottleneckCSP, [ 128 ] ],
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
+    [ -1, 9, BottleneckCSP, [ 256 ] ],
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
+    [ -1, 9, BottleneckCSP, [ 512 ] ],
+    [ -1, 1, Conv, [ 1024, 3, 2 ] ],  # 7-P5/32
+    [ -1, 1, SPP, [ 1024, [ 5, 9, 13 ] ] ],
+    [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 9
+  ]
+
+# YOLOv5 head
+head:
+  [ [ -1, 1, Conv, [ 512, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 13
+
+    [ -1, 1, Conv, [ 256, 1, 1 ] ],
+    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
+    [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
+    [ -1, 3, BottleneckCSP, [ 256, False ] ],  # 17 (P3/8-small)
+
+    [ -1, 1, Conv, [ 256, 3, 2 ] ],
+    [ [ -1, 14 ], 1, Concat, [ 1 ] ],  # cat head P4
+    [ -1, 3, BottleneckCSP, [ 512, False ] ],  # 20 (P4/16-medium)
+
+    [ -1, 1, Conv, [ 512, 3, 2 ] ],
+    [ [ -1, 10 ], 1, Concat, [ 1 ] ],  # cat head P5
+    [ -1, 3, BottleneckCSP, [ 1024, False ] ],  # 23 (P5/32-large)
+
+    [ [ 17, 20, 23 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5)
+  ]

metadata/predictor_yolo_detector/runs/exp0_yolov5s_results/events.out.tfevents.1604565595.828c870bfd5d.342.0

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

metadata/predictor_yolo_detector/runs/exp0_yolov5s_results/hyp.yaml

@@ -0,0 +1,27 @@
+lr0: 0.01
+lrf: 0.2
+momentum: 0.937
+weight_decay: 0.0005
+warmup_epochs: 3.0
+warmup_momentum: 0.8
+warmup_bias_lr: 0.1
+box: 0.05
+cls: 0.5
+cls_pw: 1.0
+obj: 1.0
+obj_pw: 1.0
+iou_t: 0.2
+anchor_t: 4.0
+fl_gamma: 0.0
+hsv_h: 0.015
+hsv_s: 0.7
+hsv_v: 0.4
+degrees: 0.0
+translate: 0.1
+scale: 0.5
+shear: 0.0
+perspective: 0.0
+flipud: 0.0
+fliplr: 0.5
+mosaic: 1.0
+mixup: 0.0

metadata/predictor_yolo_detector/runs/exp0_yolov5s_results/opt.yaml

@@ -0,0 +1,31 @@
+weights: ''
+cfg: ./models/custom_yolov5s.yaml
+data: /content/drive/My Drive/Factory Security Automation/dataset/Fire_Smoke/data.yaml
+hyp: data/hyp.scratch.yaml
+epochs: 100
+batch_size: 16
+img_size:
+  - 416
+  - 416
+rect: false
+resume: false
+nosave: false
+notest: false
+noautoanchor: false
+evolve: false
+bucket: ''
+cache_images: true
+image_weights: false
+name: yolov5s_results
+device: ''
+multi_scale: false
+single_cls: false
+adam: false
+sync_bn: false
+local_rank: -1
+logdir: runs/
+log_imgs: 0
+workers: 8
+total_batch_size: 16
+world_size: 1
+global_rank: -1

metadata/predictor_yolo_detector/runs/exp1_yolov5s_results/events.out.tfevents.1604565658.828c870bfd5d.369.0

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

metadata/predictor_yolo_detector/runs/exp1_yolov5s_results/hyp.yaml

@@ -0,0 +1,27 @@
+lr0: 0.01
+lrf: 0.2
+momentum: 0.937
+weight_decay: 0.0005
+warmup_epochs: 3.0
+warmup_momentum: 0.8
+warmup_bias_lr: 0.1
+box: 0.05
+cls: 0.5
+cls_pw: 1.0
+obj: 1.0
+obj_pw: 1.0
+iou_t: 0.2
+anchor_t: 4.0
+fl_gamma: 0.0
+hsv_h: 0.015
+hsv_s: 0.7
+hsv_v: 0.4
+degrees: 0.0
+translate: 0.1
+scale: 0.5
+shear: 0.0
+perspective: 0.0
+flipud: 0.0
+fliplr: 0.5
+mosaic: 1.0
+mixup: 0.0

metadata/predictor_yolo_detector/runs/exp1_yolov5s_results/opt.yaml

@@ -0,0 +1,31 @@
+weights: ''
+cfg: ./models/custom_yolov5s.yaml
+data: /content/drive/My Drive/Factory Security Automation/dataset/Fire_Smoke/data.yaml
+hyp: data/hyp.scratch.yaml
+epochs: 100
+batch_size: 16
+img_size:
+  - 416
+  - 416
+rect: false
+resume: false
+nosave: false
+notest: false
+noautoanchor: false
+evolve: false
+bucket: ''
+cache_images: true
+image_weights: false
+name: yolov5s_results
+device: ''
+multi_scale: false
+single_cls: false
+adam: false
+sync_bn: false
+local_rank: -1
+logdir: runs/
+log_imgs: 0
+workers: 8
+total_batch_size: 16
+world_size: 1
+global_rank: -1

metadata/predictor_yolo_detector/runs/exp1_yolov5s_results/results.txt

@@ -0,0 +1,100 @@
+      0/99     1.81G   0.09893   0.04764   0.02131    0.1679        30       416         0         0  0.001587 0.0002944   0.08504   0.02206   0.03531
+      1/99     1.81G   0.09344   0.04973   0.01541    0.1586        40       416         0         0  0.005799  0.001407   0.08099   0.02243   0.03596
+      2/99     1.81G   0.08784   0.04993   0.01227      0.15        32       416   0.01432   0.01075  0.003013 0.0005957   0.08129   0.02286   0.03354
+      3/99     1.82G   0.08028   0.05145  0.009282     0.141        35       416  0.001481   0.01075  0.002394 0.0005067   0.08033   0.02581   0.02608
+      4/99     1.82G   0.07551   0.05114  0.007099    0.1337        34       416   0.01091   0.04139  0.002496 0.0004708   0.07839    0.0237    0.0394
+      5/99     1.82G    0.0707   0.05078  0.005377    0.1269        35       416   0.00772   0.06718  0.003629 0.0007497   0.07799   0.02498   0.03243
+      6/99     1.82G   0.06663   0.04872  0.004305    0.1197        35       416   0.01284    0.2059   0.01187  0.003024   0.07354   0.03182   0.02271
+      7/99     1.82G   0.06207   0.04577  0.003588    0.1114        33       416   0.01773   0.03602  0.005831  0.001438    0.0773   0.02229    0.0292
+      8/99     1.82G   0.05921   0.04342   0.00287    0.1055        37       416   0.01854    0.2053   0.01263  0.002853   0.06826   0.03094   0.02368
+      9/99     1.82G   0.05657   0.04126  0.002692    0.1005        25       416   0.03702    0.2177   0.05131   0.01846   0.06741   0.02426   0.02812
+     10/99     1.82G   0.05436   0.03943  0.002331   0.09612        32       416    0.0588    0.2129   0.03189  0.009211   0.06712   0.02804   0.04081
+     11/99     1.82G   0.05269   0.03888  0.002292   0.09386        34       416   0.04649    0.2464   0.05502   0.02069   0.06784   0.02609   0.02809
+     12/99     1.82G   0.05104   0.03803  0.001927     0.091        34       416   0.03231    0.2521   0.05141   0.01356   0.06666    0.0252   0.02543
+     13/99     1.82G   0.04998   0.03688  0.001914   0.08878        28       416   0.04019    0.2214   0.05516   0.01728   0.06618   0.02353   0.02053
+     14/99     1.82G   0.04853   0.03689  0.001747   0.08716        26       416   0.04947    0.2698   0.05401   0.01793   0.06578   0.02403   0.01927
+     15/99     1.82G   0.04742   0.03596  0.001539   0.08492        34       416   0.05023    0.2295   0.05609   0.02081   0.06588   0.02474   0.02174
+     16/99     1.82G   0.04651   0.03519  0.001496   0.08319        37       416   0.03594    0.1779   0.05644   0.01819   0.06521   0.02446   0.02155
+     17/99     1.82G   0.04556   0.03465  0.001401   0.08161        31       416   0.04865    0.2741   0.06832   0.02672   0.06373   0.02337   0.01956
+     18/99     1.82G   0.04499   0.03426  0.001472   0.08071        35       416   0.04921    0.2585   0.08185   0.03131   0.06576   0.02329   0.02796
+     19/99     1.82G   0.04434   0.03451  0.001371   0.08021        36       416    0.0441    0.2676   0.08527    0.0253    0.0657   0.02383   0.01746
+     20/99     1.82G   0.04314   0.03314  0.001416   0.07769        36       416   0.04411    0.2144   0.05299   0.02149   0.06512   0.02501    0.0202
+     21/99     1.82G   0.04277   0.03305  0.001311   0.07714        34       416   0.04467    0.2381   0.05648   0.01529   0.06593   0.02413   0.02592
+     22/99     1.82G   0.04213   0.03229  0.001334   0.07575        35       416   0.07915     0.236   0.06322   0.01497   0.06624   0.02392   0.03236
+     23/99     1.82G   0.04152   0.03256   0.00114   0.07522        34       416   0.03371    0.2182   0.03018  0.009125   0.06527   0.02787   0.02136
+     24/99     1.82G   0.04097     0.032   0.00104     0.074        44       416   0.06347    0.1817   0.07005   0.02203   0.06461   0.02434   0.03134
+     25/99     1.82G   0.04079   0.03207  0.001136   0.07399        44       416   0.05743    0.2016   0.06142   0.02198   0.06408   0.02473   0.02933
+     26/99     1.82G   0.04057   0.03112  0.001092   0.07278        37       416   0.05116    0.1473   0.04281   0.01783   0.06544   0.02432   0.02658
+     27/99     1.82G   0.03921    0.0305  0.001197   0.07091        35       416   0.05939    0.2137   0.07203    0.0186   0.06598   0.02327   0.02478
+     28/99     1.82G   0.03929   0.03088  0.001088   0.07125        38       416   0.04667    0.1892   0.04484   0.01265   0.06675   0.02642   0.02214
+     29/99     1.82G   0.03889   0.03057  0.001078   0.07054        42       416    0.1081    0.2225   0.07418   0.03127   0.06701   0.02537   0.03313
+     30/99     1.82G   0.03866   0.03029  0.001163   0.07011        35       416    0.0507    0.2043   0.07113   0.02053   0.06582   0.02442    0.0274
+     31/99     1.82G   0.03812   0.02989  0.001115   0.06913        41       416   0.07134    0.2118   0.05145   0.01356   0.06666   0.02828   0.02723
+     32/99     1.82G   0.03754   0.02953 0.0009821   0.06805        31       416   0.04466    0.1795   0.05775   0.02495   0.06641   0.02562   0.02646
+     33/99     1.82G   0.03749   0.02937  0.001026   0.06789        28       416   0.06486     0.172   0.05876   0.02403   0.06531   0.02484   0.03947
+     34/99     1.82G   0.03683   0.02874 0.0008897   0.06646        33       416   0.05251    0.1715   0.07841   0.03514   0.06499   0.02397   0.03911
+     35/99     1.82G   0.03678   0.02906 0.0009355   0.06677        33       416   0.05911    0.1849   0.07483    0.0309   0.06571   0.02463   0.03404
+     36/99     1.82G   0.03582   0.02807 0.0008915   0.06478        29       416   0.06801    0.2311   0.09068   0.03254   0.06554   0.02431   0.02458
+     37/99     1.82G   0.03589   0.02868 0.0009573   0.06552        37       416   0.05897     0.259   0.07025   0.02419   0.06471   0.02421   0.02755
+     38/99     1.82G   0.03576   0.02835 0.0009018   0.06501        33       416   0.06878    0.1689   0.05431   0.01683   0.06609   0.02504   0.02782
+     39/99     1.82G   0.03548   0.02775  0.001018   0.06425        32       416   0.05994    0.2639   0.07841   0.02884   0.06302   0.02464   0.02572
+     40/99     1.82G   0.03471   0.02764  0.001074   0.06342        39       416   0.06073     0.172   0.05433   0.02337   0.06646    0.0243   0.02453
+     41/99     1.82G   0.03427    0.0277 0.0007684   0.06273        34       416   0.05228    0.1716   0.06343   0.02321   0.06575   0.02656   0.02478
+     42/99     1.82G   0.03409   0.02698  0.000711   0.06178        35       416   0.05419    0.1811   0.07327   0.02578   0.06515   0.02367   0.02294
+     43/99     1.82G   0.03413    0.0275 0.0007858   0.06242        37       416   0.06028    0.2633   0.07119   0.02687   0.06336   0.02412   0.02402
+     44/99     1.82G   0.03395    0.0273 0.0008348   0.06208        35       416   0.06234    0.2069   0.05342   0.01517   0.06587     0.025   0.02885
+     45/99     1.82G   0.03391   0.02725 0.0007883   0.06195        35       416   0.03548    0.1618   0.08076   0.03325   0.06703   0.02426   0.03585
+     46/99     1.82G   0.03327   0.02711  0.000814    0.0612        36       416   0.06062      0.15   0.06311   0.02728    0.0669   0.02457   0.03052
+     47/99     1.82G   0.03314   0.02687 0.0007741   0.06079        33       416   0.05882    0.1623   0.06726   0.02572   0.06593   0.02574   0.03263
+     48/99     1.82G   0.03269   0.02613 0.0007547   0.05958        46       416    0.0668    0.1849    0.0746   0.03231   0.06439   0.02563   0.02913
+     49/99     1.82G    0.0325   0.02625 0.0009518    0.0597        34       416   0.04818    0.1881    0.0673   0.02661   0.06696    0.0255   0.03222
+     50/99     1.82G   0.03242   0.02669 0.0007682   0.05988        33       416   0.06559    0.1887   0.06419   0.02415   0.06374   0.02534   0.03064
+     51/99     1.82G   0.03222   0.02623 0.0008339   0.05928        45       416   0.06583    0.1505   0.05873   0.02629   0.06751   0.02481   0.03065
+     52/99     1.82G   0.03218   0.02625 0.0007168   0.05915        40       416   0.07037     0.172   0.07119     0.033   0.06663   0.02512   0.03217
+     53/99     1.82G   0.03177    0.0261 0.0006838   0.05856        29       416   0.04996    0.1355    0.0561   0.02383   0.06828   0.02497   0.03567
+     54/99     1.82G   0.03157   0.02546 0.0007498   0.05779        29       416    0.0804    0.1822      0.07   0.02763    0.0658   0.02441   0.03856
+     55/99     1.82G   0.03091   0.02491 0.0007254   0.05655        29       416    0.1062    0.2268   0.09232   0.03424   0.06595   0.02258   0.02559
+     56/99     1.82G   0.03122   0.02539 0.0007681   0.05737        32       416   0.05518    0.1677   0.05497   0.02257   0.06654   0.02742   0.03168
+     57/99     1.82G   0.03099   0.02474 0.0006948   0.05642        28       416   0.08698    0.1575    0.0484   0.01746   0.06675   0.02576   0.03131
+     58/99     1.82G   0.03033   0.02465 0.0008397   0.05583        35       416   0.08594     0.165   0.06749   0.02868   0.06517    0.0262   0.02958
+     59/99     1.82G   0.03043   0.02477 0.0007128   0.05591        28       416   0.05579    0.1994   0.06667   0.02366   0.06477    0.0252   0.03023
+     60/99     1.82G   0.02964    0.0239 0.0006062   0.05415        30       416   0.08714    0.1887   0.07176   0.02187   0.06539    0.0253   0.02587
+     61/99     1.82G   0.02992   0.02428 0.0008142   0.05502        28       416   0.06426    0.1666   0.07668   0.03018   0.06625   0.02599   0.03827
+     62/99     1.82G   0.02937   0.02416 0.0007393   0.05427        31       416   0.06483    0.1672   0.07641   0.03143   0.06552   0.02601   0.02674
+     63/99     1.82G   0.02954   0.02407 0.0006106   0.05422        37       416   0.06024     0.136   0.05373   0.02556   0.06761   0.02717   0.03878
+     64/99     1.82G   0.02919   0.02371 0.0006706   0.05357        52       416   0.07542    0.1924   0.07466   0.03114   0.06665   0.02434   0.02677
+     65/99     1.82G   0.02905   0.02305  0.000703    0.0528        32       416   0.05857    0.1688   0.05535   0.02363   0.06605   0.02567   0.02736
+     66/99     1.82G   0.02866   0.02315 0.0005723   0.05238        30       416   0.06874    0.1924   0.06045   0.02389   0.06684   0.02559   0.03497
+     67/99     1.82G   0.02882   0.02312  0.000545   0.05248        34       416   0.07738    0.1747   0.06953    0.0303   0.06643   0.02542   0.03153
+     68/99     1.82G   0.02845   0.02317 0.0006277   0.05226        34       416   0.09113    0.1677   0.06334   0.02466   0.06758   0.02589   0.05093
+     69/99     1.82G   0.02839   0.02344 0.0005977   0.05243        33       416   0.06885    0.1731   0.05824   0.01981   0.06547   0.02576   0.03899
+     70/99     1.82G   0.02791    0.0228  0.000616   0.05133        34       416   0.08296    0.2252   0.09107   0.03721   0.06375   0.02519   0.02305
+     71/99     1.82G   0.02783   0.02251 0.0006301   0.05098        33       416     0.107    0.1629   0.07936   0.03225   0.06665   0.02669   0.03384
+     72/99     1.82G   0.02764   0.02298 0.0006631   0.05128        30       416   0.06204    0.1672   0.06169   0.02566   0.06585   0.02572   0.03274
+     73/99     1.82G   0.02749   0.02266 0.0006699   0.05082        32       416   0.06946     0.179   0.06772   0.02775   0.06658   0.02605    0.0337
+     74/99     1.82G   0.02697   0.02259 0.0006182   0.05018        31       416   0.08451    0.1838   0.07818   0.03035   0.06688    0.0253   0.03588
+     75/99     1.82G   0.02719   0.02252 0.0005216   0.05023        31       416   0.07323    0.1612   0.07149   0.02854   0.06807   0.02594   0.03716
+     76/99     1.82G   0.02725   0.02234 0.0004887   0.05008        31       416   0.08067    0.1634   0.07874   0.03363   0.06735   0.02562   0.03068
+     77/99     1.82G   0.02745     0.022 0.0005644   0.05002        30       416   0.06627    0.1876   0.07775   0.03286   0.06695   0.02587   0.03243
+     78/99     1.82G   0.02653   0.02192 0.0005903   0.04904        36       416   0.09917    0.1812   0.07785   0.02913   0.06707   0.02513   0.03151
+     79/99     1.82G   0.02684   0.02257  0.000562   0.04997        39       416   0.05564    0.1526   0.05876   0.02633   0.06746   0.02618   0.03566
+     80/99     1.82G   0.02673   0.02188 0.0005288   0.04914        30       416   0.08089    0.1859   0.07233   0.02725    0.0666   0.02622   0.03448
+     81/99     1.82G   0.02646   0.02194 0.0005107   0.04892        34       416   0.06028    0.1698   0.06026   0.02502   0.06615    0.0269   0.03563
+     82/99     1.82G   0.02617   0.02159  0.000595   0.04835        29       416   0.06385    0.1585   0.06293   0.02799   0.06571   0.02701   0.03528
+     83/99     1.82G   0.02604   0.02124 0.0004056   0.04768        28       416   0.06987     0.187   0.06717   0.02929   0.06616   0.02629   0.03006
+     84/99     1.82G   0.02573   0.02162 0.0005842   0.04793        33       416   0.07749     0.179    0.0737   0.02904   0.06591   0.02666   0.03001
+     85/99     1.82G   0.02559   0.02099 0.0004245     0.047        33       416   0.06499    0.1213   0.06146   0.02877   0.06672   0.02698   0.03723
+     86/99     1.82G   0.02543   0.02096 0.0005875   0.04697        34       416   0.07738    0.1752   0.07124   0.02814   0.06586   0.02577   0.03049
+     87/99     1.82G   0.02556   0.02081 0.0005253    0.0469        35       416   0.08506    0.1704   0.06562   0.02325   0.06611   0.02683    0.0293
+     88/99     1.82G   0.02565   0.02129 0.0005002   0.04744        25       416    0.1032    0.2139   0.07841   0.03021   0.06443     0.027   0.02538
+     89/99     1.82G   0.02527   0.02095 0.0004493   0.04668        27       416   0.07521     0.129      0.07    0.0293   0.06717   0.02677     0.037
+     90/99     1.82G   0.02508   0.02057 0.0005487    0.0462        38       416    0.0543    0.1317   0.05963   0.02459   0.06709   0.02688   0.03416
+     91/99     1.82G   0.02524   0.02082 0.0004508   0.04651        27       416   0.06223    0.1564   0.06508   0.02967   0.06637   0.02682   0.03376
+     92/99     1.82G   0.02519   0.02103  0.000424   0.04665        49       416    0.0764    0.1902   0.07643   0.03485    0.0672   0.02529   0.02728
+     93/99     1.82G   0.02532   0.02064 0.0005462    0.0465        40       416   0.06959    0.1924   0.07251   0.02783   0.06521   0.02599   0.02777
+     94/99     1.82G   0.02496   0.02044  0.000513   0.04591        33       416    0.0755    0.1505   0.05635    0.0219   0.06826   0.02616   0.03474
+     95/99     1.82G   0.02479   0.02023 0.0004699   0.04549        37       416   0.08039    0.1419   0.05785   0.02388   0.06745   0.02636   0.03429
+     96/99     1.82G   0.02471   0.02026 0.0004353   0.04541        27       416    0.0647     0.114   0.05691   0.02578    0.0689   0.02652   0.03532
+     97/99     1.82G   0.02477    0.0202  0.000512   0.04548        39       416   0.07329    0.1859   0.06612    0.0242   0.06666   0.02636   0.03026
+     98/99     1.82G   0.02466   0.02006 0.0005136   0.04523        28       416   0.08644    0.1887   0.06246   0.02416   0.06699   0.02501    0.0358
+     99/99     1.82G   0.02438   0.02024 0.0004354   0.04505        28       416    0.0765    0.1918   0.06221    0.0229   0.06631    0.0257   0.03321