init

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.weights filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,48 @@
+import numpy as np
+import gradio as gr
+from model import api
+from PIL import Image
+from yolo.model import *
+
+model = yolo_model()
+
+def predict(input_img):
+    input_img = Image.fromarray(input_img)
+    _, payload = model.predict(image)
+    # print('prediction',prediction)
+    return payload
+
+css = ''
+
+# with gr.Blocks(css=css) as demo:
+#     gr.HTML("<h1><center>Signsapp: Classify the signs based on the hands sign images<center><h1>")
+#     gr.Interface(sign,inputs=gr.Image(shape=(200, 200)), outputs=gr.Label())
+
+title = r"yolov3"
+
+description = r"""
+<center>
+Recognize common objects using the model
+<img src="file/det_dog-cycle-car.png" width=350px>
+</center>
+"""
+article = r"""
+### Credits
+- [Coursera](https://www.coursera.org/learn/convolutional-neural-networks/)
+"""
+
+demo = gr.Interface(
+    title = title,
+    description = description,
+    article = article, 
+    fn=predict,
+    inputs = gr.Image(shape=(200, 200)),
+    outputs = gr.Image(shape=(200, 200)),
+    examples=["dog-cycle-car.png"]
+    # allow_flagging = "manual",
+    # flagging_options = ['recule', 'tournedroite', 'arretetoi', 'tournegauche', 'gauche', 'avance', 'droite'],
+    # flagging_dir = "./flag/men"
+)
+
+# demo.queue()
+demo.launch(debug=True)

requirements.txt

@@ -0,0 +1,8 @@
+Flask-Cors
+Flask
+Werkzeug
+pillow
+numpy
+boto3
+pytorch==1.7.1
+opencv==3.4.2

yolo/README.md

@@ -0,0 +1,12 @@
+## Yolo
+
+[Part 1 : Understanding How YOLO works](https://blog.paperspace.com/how-to-implement-a-yolo-object-detector-in-pytorch/)
+
+[Part 2 : Creating the layers of the network architecture](https://blog.paperspace.com/how-to-implement-a-yolo-v3-object-detector-from-scratch-in-pytorch-part-2/)
+
+[Part 3 : How to implement a YOLO (v3) object detector from scratch in PyTorch](https://blog.paperspace.com/how-to-implement-a-yolo-v3-object-detector-from-scratch-in-pytorch-part-3/)
+
+[Part 4 : Objectness Confidence Thresholding and Non-maximum Suppression](https://blog.paperspace.com/how-to-implement-a-yolo-v3-object-detector-from-scratch-in-pytorch-part-4/)
+
+[Part 5 : Designing the input and the output pipelines](https://blog.paperspace.com/how-to-implement-a-yolo-v3-object-detector-from-scratch-in-pytorch-part-5/)
+

yolo/cfg/yolov3.cfg

@@ -0,0 +1,788 @@
+[net]
+# Testing
+# batch=1
+# subdivisions=1
+# Training
+batch=64
+subdivisions=16
+width=624
+height=624
+channels=3
+momentum=0.9
+decay=0.0005
+angle=0
+saturation = 1.5
+exposure = 1.5
+hue=.1
+
+learning_rate=0.001
+burn_in=1000
+max_batches = 500200
+policy=steps
+steps=400000,450000
+scales=.1,.1
+
+[convolutional]
+batch_normalize=1
+filters=32
+size=3
+stride=1
+pad=1
+activation=leaky
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=3
+stride=2
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=32
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=2
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=2
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=2
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=2
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+######################
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=1024
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=1024
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=1024
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+
+[yolo]
+mask = 6,7,8
+anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
+classes=80
+num=9
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+random=1
+
+
+[route]
+layers = -4
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[upsample]
+stride=2
+
+[route]
+layers = -1, 61
+
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=512
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=512
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=512
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+
+[yolo]
+mask = 3,4,5
+anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
+classes=80
+num=9
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+random=1
+
+
+
+[route]
+layers = -4
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[upsample]
+stride=2
+
+[route]
+layers = -1, 36
+
+
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=256
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=256
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=256
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+
+[yolo]
+mask = 0,1,2
+anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
+classes=80
+num=9
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+random=1

yolo/darknet.py

@@ -0,0 +1,586 @@
+from __future__ import division
+
+import torch 
+import torch.nn as nn
+import torch.nn.functional as F 
+from torch.autograd import Variable
+import numpy as np
+from PIL import Image
+
+from yolo.utils import * 
+
+# from utils import * 
+
+def get_test_input_normal():
+
+    input_image = "dog-cycle-car.png"
+    image = Image.open(input_image)
+    image = image.convert("RGB")
+
+    img = image.resize(( 416 , 416 ))
+
+    img = np.asarray(img)
+
+    img_ =  img[:,:,::-1].transpose((2,0,1))  # BGR -> RGB | H X W C -> C X H X W 
+    img_ = img_[np.newaxis,:,:,:]/255.0       #Add a channel at 0 (for batch) | Normalise
+    img_ = torch.from_numpy(img_).float()     #Convert to float
+    img_ = Variable(img_)                     # Convert to Variable
+    return img_
+
+def get_test_input():
+    img = cv2.imread("dog-cycle-car.png")
+    img = cv2.resize(img, (416,416))          #Resize to the input dimension
+    img_ =  img[:,:,::-1].transpose((2,0,1))  # BGR -> RGB | H X W C -> C X H X W 
+    img_ = img_[np.newaxis,:,:,:]/255.0       #Add a channel at 0 (for batch) | Normalise
+    img_ = torch.from_numpy(img_).float()     #Convert to float
+    img_ = Variable(img_)                     # Convert to Variable
+    return img_
+
+
+def parse_cfg(cfgfile):
+    """
+    Takes a configuration file
+    
+    Returns a list of blocks. Each blocks describes a block in the neural
+    network to be built. Block is represented as a dictionary in the list
+    
+    """
+    file = open(cfgfile, 'r')
+    lines = file.read().split('\n')     #store the lines in a list
+    lines = [x for x in lines if len(x) > 0] #get read of the empty lines 
+    lines = [x for x in lines if x[0] != '#']  
+    lines = [x.rstrip().lstrip() for x in lines]
+
+    
+    block = {}
+    blocks = []
+    
+    for line in lines:
+        if line[0] == "[":               #This marks the start of a new block
+            if len(block) != 0:
+                blocks.append(block)
+                block = {}
+            block["type"] = line[1:-1].rstrip()
+        else:
+            key,value = line.split("=")
+            block[key.rstrip()] = value.lstrip()
+    blocks.append(block)
+
+    return blocks
+#    print('\n\n'.join([repr(x) for x in blocks]))
+
+import pickle as pkl
+
+class MaxPoolStride1(nn.Module):
+    def __init__(self, kernel_size):
+        super(MaxPoolStride1, self).__init__()
+        self.kernel_size = kernel_size
+        self.pad = kernel_size - 1
+    
+    def forward(self, x):
+        padded_x = F.pad(x, (0,self.pad,0,self.pad), mode="replicate")
+        pooled_x = nn.MaxPool2d(self.kernel_size, self.pad)(padded_x)
+        return pooled_x
+    
+
+class EmptyLayer(nn.Module):
+    def __init__(self):
+        super(EmptyLayer, self).__init__()
+        
+
+class DetectionLayer(nn.Module):
+    def __init__(self, anchors):
+        super(DetectionLayer, self).__init__()
+        self.anchors = anchors
+    
+    def forward(self, x, inp_dim, num_classes, confidence):
+        x = x.data
+        global CUDA
+        prediction = x
+        prediction = predict_transform(prediction, inp_dim, self.anchors, num_classes, confidence, CUDA)
+        return prediction
+        
+
+        
+
+
+class Upsample(nn.Module):
+    def __init__(self, stride=2):
+        super(Upsample, self).__init__()
+        self.stride = stride
+        
+    def forward(self, x):
+        stride = self.stride
+        assert(x.data.dim() == 4)
+        B = x.data.size(0)
+        C = x.data.size(1)
+        H = x.data.size(2)
+        W = x.data.size(3)
+        ws = stride
+        hs = stride
+        x = x.view(B, C, H, 1, W, 1).expand(B, C, H, stride, W, stride).contiguous().view(B, C, H*stride, W*stride)
+        return x
+#       
+        
+class ReOrgLayer(nn.Module):
+    def __init__(self, stride = 2):
+        super(ReOrgLayer, self).__init__()
+        self.stride= stride
+        
+    def forward(self,x):
+        assert(x.data.dim() == 4)
+        B,C,H,W = x.data.shape
+        hs = self.stride
+        ws = self.stride
+        assert(H % hs == 0),  "The stride " + str(self.stride) + " is not a proper divisor of height " + str(H)
+        assert(W % ws == 0),  "The stride " + str(self.stride) + " is not a proper divisor of height " + str(W)
+        x = x.view(B,C, H // hs, hs, W // ws, ws).transpose(-2,-3).contiguous()
+        x = x.view(B,C, H // hs * W // ws, hs, ws)
+        x = x.view(B,C, H // hs * W // ws, hs*ws).transpose(-1,-2).contiguous()
+        x = x.view(B, C, ws*hs, H // ws, W // ws).transpose(1,2).contiguous()
+        x = x.view(B, C*ws*hs, H // ws, W // ws)
+        return x
+
+
+def create_modules(blocks):
+    net_info = blocks[0]     #Captures the information about the input and pre-processing    
+    
+    module_list = nn.ModuleList()
+    
+    index = 0    #indexing blocks helps with implementing route  layers (skip connections)
+
+    
+    prev_filters = 3
+    
+    output_filters = []
+    
+    for x in blocks:
+        module = nn.Sequential()
+        
+        if (x["type"] == "net"):
+            continue
+        
+        #If it's a convolutional layer
+        if (x["type"] == "convolutional"):
+            #Get the info about the layer
+            activation = x["activation"]
+            try:
+                batch_normalize = int(x["batch_normalize"])
+                bias = False
+            except:
+                batch_normalize = 0
+                bias = True
+                
+            filters= int(x["filters"])
+            padding = int(x["pad"])
+            kernel_size = int(x["size"])
+            stride = int(x["stride"])
+            
+            if padding:
+                pad = (kernel_size - 1) // 2
+            else:
+                pad = 0
+                
+            #Add the convolutional layer
+            conv = nn.Conv2d(prev_filters, filters, kernel_size, stride, pad, bias = bias)
+            module.add_module("conv_{0}".format(index), conv)
+            
+            #Add the Batch Norm Layer
+            if batch_normalize:
+                bn = nn.BatchNorm2d(filters)
+                module.add_module("batch_norm_{0}".format(index), bn)
+            
+            #Check the activation. 
+            #It is either Linear or a Leaky ReLU for YOLO
+            if activation == "leaky":
+                activn = nn.LeakyReLU(0.1, inplace = True)
+                module.add_module("leaky_{0}".format(index), activn)
+            
+            
+            
+        #If it's an upsampling layer
+        #We use Bilinear2dUpsampling
+        
+        elif (x["type"] == "upsample"):
+            stride = int(x["stride"])
+#            upsample = Upsample(stride)
+            upsample = nn.Upsample(scale_factor = 2, mode = "nearest")
+            module.add_module("upsample_{}".format(index), upsample)
+        
+        #If it is a route layer
+        elif (x["type"] == "route"):
+            x["layers"] = x["layers"].split(',')
+            
+            #Start  of a route
+            start = int(x["layers"][0])
+            
+            #end, if there exists one.
+            try:
+                end = int(x["layers"][1])
+            except:
+                end = 0
+                
+            
+            
+            #Positive anotation
+            if start > 0: 
+                start = start - index
+            
+            if end > 0:
+                end = end - index
+
+            
+            route = EmptyLayer()
+            module.add_module("route_{0}".format(index), route)
+            
+            
+            
+            if end < 0:
+                filters = output_filters[index + start] + output_filters[index + end]
+            else:
+                filters= output_filters[index + start]
+                        
+            
+        
+        #shortcut corresponds to skip connection
+        elif x["type"] == "shortcut":
+            from_ = int(x["from"])
+            shortcut = EmptyLayer()
+            module.add_module("shortcut_{}".format(index), shortcut)
+            
+            
+        elif x["type"] == "maxpool":
+            stride = int(x["stride"])
+            size = int(x["size"])
+            if stride != 1:
+                maxpool = nn.MaxPool2d(size, stride)
+            else:
+                maxpool = MaxPoolStride1(size)
+            
+            module.add_module("maxpool_{}".format(index), maxpool)
+        
+        #Yolo is the detection layer
+        elif x["type"] == "yolo":
+            mask = x["mask"].split(",")
+            mask = [int(x) for x in mask]
+            
+            
+            anchors = x["anchors"].split(",")
+            anchors = [int(a) for a in anchors]
+            anchors = [(anchors[i], anchors[i+1]) for i in range(0, len(anchors),2)]
+            anchors = [anchors[i] for i in mask]
+            
+            detection = DetectionLayer(anchors)
+            module.add_module("Detection_{}".format(index), detection)
+        
+            
+            
+        else:
+            print("Something I dunno")
+            assert False
+
+
+        module_list.append(module)
+        prev_filters = filters
+        output_filters.append(filters)
+        index += 1
+        
+    
+    return (net_info, module_list)
+
+
+
+class Darknet(nn.Module):
+    def __init__(self, cfgfile):
+        super(Darknet, self).__init__()
+        self.blocks = parse_cfg(cfgfile)
+        self.net_info, self.module_list = create_modules(self.blocks)
+        self.header = torch.IntTensor([0,0,0,0])
+        self.seen = 0
+
+        
+        
+    def get_blocks(self):
+        return self.blocks
+    
+    def get_module_list(self):
+        return self.module_list
+
+                
+    def forward(self, x, CUDA):
+        detections = []
+        modules = self.blocks[1:]
+        outputs = {}   #We cache the outputs for the route layer
+        
+        
+        write = 0
+        for i in range(len(modules)):        
+            
+            module_type = (modules[i]["type"])
+            if module_type == "convolutional" or module_type == "upsample" or module_type == "maxpool":
+                
+                x = self.module_list[i](x)
+                outputs[i] = x
+
+                
+            elif module_type == "route":
+                layers = modules[i]["layers"]
+                layers = [int(a) for a in layers]
+                
+                if (layers[0]) > 0:
+                    layers[0] = layers[0] - i
+
+                if len(layers) == 1:
+                    x = outputs[i + (layers[0])]
+
+                else:
+                    if (layers[1]) > 0:
+                        layers[1] = layers[1] - i
+                        
+                    map1 = outputs[i + layers[0]]
+                    map2 = outputs[i + layers[1]]
+                    
+                    
+                    x = torch.cat((map1, map2), 1)
+                outputs[i] = x
+            
+            elif  module_type == "shortcut":
+                from_ = int(modules[i]["from"])
+                x = outputs[i-1] + outputs[i+from_]
+                outputs[i] = x
+                
+            
+            
+            elif module_type == 'yolo':        
+                
+                anchors = self.module_list[i][0].anchors
+                #Get the input dimensions
+                inp_dim = int (self.net_info["height"])
+                
+                #Get the number of classes
+                num_classes = int (modules[i]["classes"])
+                
+                #Output the result
+                x = x.data
+                x = predict_transform(x, inp_dim, anchors, num_classes, CUDA)
+                
+                if type(x) == int:
+                    continue
+
+                
+                if not write:
+                    detections = x
+                    write = 1
+                
+                else:
+                    detections = torch.cat((detections, x), 1)
+                
+                outputs[i] = outputs[i-1]
+                
+        
+        
+        try:
+            return detections
+        except:
+            return 0
+
+    def load_weights_url(self, weightfile):
+
+        # Open the weights file
+        fp = get_data_s3(weightfile)
+
+        # The first 5 values are header information 
+        # 1. Major version number
+        # 2. Minor Version Number
+        # 3. Subversion number 
+        # 4,5. Images seen by the network (during training)
+        header = np.frombuffer( fp.getvalue() , dtype = np.int32, count = 5)
+        self.header = torch.from_numpy(header)
+        self.seen = self.header[3]
+
+        weights = np.frombuffer( fp.getvalue() , dtype = np.float32)
+
+        ptr = 0
+        
+        for i in range(len(self.module_list)):
+            module_type = self.blocks[i + 1]["type"]
+
+            #If module_type is convolutional load weights
+            #Otherwise ignore.
+
+            if module_type == "convolutional":
+                model = self.module_list[i]
+                try:
+                    batch_normalize = int(self.blocks[i+1]["batch_normalize"])
+                except:
+                    batch_normalize = 0
+
+                conv = model[0]
+
+                if (batch_normalize):
+                    bn = model[1]
+
+                    #Get the number of weights of Batch Norm Layer
+                    num_bn_biases = bn.bias.numel()
+
+                    #Load the weights
+                    bn_biases = torch.from_numpy(weights[ptr:ptr + num_bn_biases])
+                    ptr += num_bn_biases
+
+                    bn_weights = torch.from_numpy(weights[ptr: ptr + num_bn_biases])
+                    ptr  += num_bn_biases
+
+                    bn_running_mean = torch.from_numpy(weights[ptr: ptr + num_bn_biases])
+                    ptr  += num_bn_biases
+
+                    bn_running_var = torch.from_numpy(weights[ptr: ptr + num_bn_biases])
+                    ptr  += num_bn_biases
+
+                    #Cast the loaded weights into dims of model weights. 
+                    bn_biases = bn_biases.view_as(bn.bias.data)
+                    bn_weights = bn_weights.view_as(bn.weight.data)
+                    bn_running_mean = bn_running_mean.view_as(bn.running_mean)
+                    bn_running_var = bn_running_var.view_as(bn.running_var)
+
+                    #Copy the data to model
+                    bn.bias.data.copy_(bn_biases)
+                    bn.weight.data.copy_(bn_weights)
+                    bn.running_mean.copy_(bn_running_mean)
+                    bn.running_var.copy_(bn_running_var)
+
+                else:
+
+                    #Number of biases
+                    num_biases = conv.bias.numel()
+
+                    #Load the weights
+                    conv_biases = torch.from_numpy(weights[ptr: ptr + num_biases])
+                    ptr = ptr + num_biases
+
+                    #reshape the loaded weights according to the dims of the model weights
+                    conv_biases = conv_biases.view_as(conv.bias.data)
+
+                    #Finally copy the data
+                    conv.bias.data.copy_(conv_biases)
+                
+                #Let us load the weights for the Convolutional layers
+                num_weights = conv.weight.numel()
+
+                #Do the same as above for weights
+                conv_weights = torch.from_numpy(weights[ptr:ptr+num_weights])
+                ptr = ptr + num_weights
+
+                conv_weights = conv_weights.view_as(conv.weight.data)
+                conv.weight.data.copy_(conv_weights)
+
+
+    def load_weights(self, weightfile):
+
+        # Open the weights file
+        fp = open(weightfile, "rb")
+
+        # The first 5 values are header information 
+        # 1. Major version number
+        # 2. Minor Version Number
+        # 3. Subversion number 
+        # 4,5. Images seen by the network (during training)
+        header = np.fromfile(fp, dtype = np.int32, count = 5)
+        self.header = torch.from_numpy(header)
+        self.seen = self.header[3]
+
+        weights = np.fromfile(fp, dtype = np.float32)
+
+        ptr = 0
+        
+        for i in range(len(self.module_list)):
+            module_type = self.blocks[i + 1]["type"]
+
+            #If module_type is convolutional load weights
+            #Otherwise ignore.
+
+            if module_type == "convolutional":
+                model = self.module_list[i]
+                try:
+                    batch_normalize = int(self.blocks[i+1]["batch_normalize"])
+                except:
+                    batch_normalize = 0
+
+                conv = model[0]
+
+                if (batch_normalize):
+                    bn = model[1]
+
+                    #Get the number of weights of Batch Norm Layer
+                    num_bn_biases = bn.bias.numel()
+
+                    #Load the weights
+                    bn_biases = torch.from_numpy(weights[ptr:ptr + num_bn_biases])
+                    ptr += num_bn_biases
+
+                    bn_weights = torch.from_numpy(weights[ptr: ptr + num_bn_biases])
+                    ptr  += num_bn_biases
+
+                    bn_running_mean = torch.from_numpy(weights[ptr: ptr + num_bn_biases])
+                    ptr  += num_bn_biases
+
+                    bn_running_var = torch.from_numpy(weights[ptr: ptr + num_bn_biases])
+                    ptr  += num_bn_biases
+
+                    #Cast the loaded weights into dims of model weights. 
+                    bn_biases = bn_biases.view_as(bn.bias.data)
+                    bn_weights = bn_weights.view_as(bn.weight.data)
+                    bn_running_mean = bn_running_mean.view_as(bn.running_mean)
+                    bn_running_var = bn_running_var.view_as(bn.running_var)
+
+                    #Copy the data to model
+                    bn.bias.data.copy_(bn_biases)
+                    bn.weight.data.copy_(bn_weights)
+                    bn.running_mean.copy_(bn_running_mean)
+                    bn.running_var.copy_(bn_running_var)
+
+                else:
+
+                    #Number of biases
+                    num_biases = conv.bias.numel()
+
+                    #Load the weights
+                    conv_biases = torch.from_numpy(weights[ptr: ptr + num_biases])
+                    ptr = ptr + num_biases
+
+                    #reshape the loaded weights according to the dims of the model weights
+                    conv_biases = conv_biases.view_as(conv.bias.data)
+
+                    #Finally copy the data
+                    conv.bias.data.copy_(conv_biases)
+                
+                #Let us load the weights for the Convolutional layers
+                num_weights = conv.weight.numel()
+
+                #Do the same as above for weights
+                conv_weights = torch.from_numpy(weights[ptr:ptr+num_weights])
+                ptr = ptr + num_weights
+
+                conv_weights = conv_weights.view_as(conv.weight.data)
+                conv.weight.data.copy_(conv_weights)
+
+
+if __name__ == '__main__':
+    
+    model = Darknet("yolov3.cfg")
+    model.load_weights_url("yolov3.weights")
+
+    CUDA = torch.cuda.is_available()
+
+    print(' cuda : ' , CUDA )
+
+    inp = get_test_input()
+    
+    # if CUDA:
+
+    #     model.cuda()
+    #     inp.cuda()
+
+    pred = model( inp , False )
+
+    print (pred)
+    print( 'shape' , pred.shape )

yolo/data/coco.names

@@ -0,0 +1,80 @@
+person
+bicycle
+car
+motorbike
+aeroplane
+bus
+train
+truck
+boat
+traffic light
+fire hydrant
+stop sign
+parking meter
+bench
+bird
+cat
+dog
+horse
+sheep
+cow
+elephant
+bear
+zebra
+giraffe
+backpack
+umbrella
+handbag
+tie
+suitcase
+frisbee
+skis
+snowboard
+sports ball
+kite
+baseball bat
+baseball glove
+skateboard
+surfboard
+tennis racket
+bottle
+wine glass
+cup
+fork
+knife
+spoon
+bowl
+banana
+apple
+sandwich
+orange
+broccoli
+carrot
+hot dog
+pizza
+donut
+cake
+chair
+sofa
+pottedplant
+bed
+diningtable
+toilet
+tvmonitor
+laptop
+mouse
+remote
+keyboard
+cell phone
+microwave
+oven
+toaster
+sink
+refrigerator
+book
+clock
+vase
+scissors
+teddy bear
+hair drier
+toothbrush

yolo/detector.py

@@ -0,0 +1,321 @@
+from __future__ import division
+import time
+import torch 
+import torch.nn as nn
+from torch.autograd import Variable
+import numpy as np
+import cv2 
+from utils import *
+import argparse
+import os 
+import os.path as osp
+from darknet import Darknet
+# from preprocess import prep_image, inp_to_image
+import pandas as pd
+import random 
+import pickle as pkl
+import itertools
+
+class test_net(nn.Module):
+    def __init__(self, num_layers, input_size):
+        super(test_net, self).__init__()
+        self.num_layers= num_layers
+        self.linear_1 = nn.Linear(input_size, 5)
+        self.middle = nn.ModuleList([nn.Linear(5,5) for x in range(num_layers)])
+        self.output = nn.Linear(5,2)
+    
+    def forward(self, x):
+        x = x.view(-1)
+        fwd = nn.Sequential(self.linear_1, *self.middle, self.output)
+        return fwd(x)
+        
+def get_test_input(input_dim, CUDA):
+    img = cv2.imread("dog-cycle-car.png")
+    img = cv2.resize(img, (input_dim, input_dim)) 
+    img_ =  img[:,:,::-1].transpose((2,0,1))
+    img_ = img_[np.newaxis,:,:,:]/255.0
+    img_ = torch.from_numpy(img_).float()
+    img_ = Variable(img_)
+    
+    if CUDA:
+        img_ = img_.cuda()
+    num_classes
+    return img_
+
+
+
+def arg_parse():
+    """
+    Parse arguements to the detect module
+    
+    """
+    
+    
+    parser = argparse.ArgumentParser(description='YOLO v3 Detection Module')
+   
+    parser.add_argument("--images", dest = 'images', help = 
+                        "Image / Directory containing images to perform detection upon",
+                        default = "imgs", type = str)
+    parser.add_argument("--det", dest = 'det', help = 
+                        "Image / Directory to store detections to",
+                        default = "det", type = str)
+    parser.add_argument("--bs", dest = "bs", help = "Batch size", default = 1)
+    parser.add_argument("--confidence", dest = "confidence", help = "Object Confidence to filter predictions", default = 0.5)
+    parser.add_argument("--nms_thresh", dest = "nms_thresh", help = "NMS Threshhold", default = 0.4)
+    parser.add_argument("--cfg", dest = 'cfgfile', help = 
+                        "Config file",
+                        default = "cfg/yolov3.cfg", type = str)
+    parser.add_argument("--weights", dest = 'weightsfile', help = 
+                        "weightsfile",
+                        default = "yolov3.weights", type = str)
+    parser.add_argument("--reso", dest = 'reso', help = 
+                        "Input resolution of the network. Increase to increase accuracy. Decrease to increase speed",
+                        default = "416", type = str)
+    parser.add_argument("--scales", dest = "scales", help = "Scales to use for detection",
+                        default = "1,2,3", type = str)
+    
+    return parser.parse_args()
+
+if __name__ ==  '__main__':
+    args = arg_parse()
+    
+    scales = args.scales
+    
+    
+#        scales = [int(x) for x in scales.split(',')]
+#        
+#        
+#        
+#        args.reso = int(args.reso)
+#        
+#        num_boxes = [args.reso//32, args.reso//16, args.reso//8]    
+#        scale_indices = [3*(x**2) for x in num_boxes]
+#        scale_indices = list(itertools.accumulate(scale_indices, lambda x,y : x+y))
+#    
+#        
+#        li = []
+#        i = 0
+#        for scale in scale_indices:        
+#            li.extend(list(range(i, scale))) 
+#            i = scale
+#        
+#        scale_indices = li
+
+    images = args.images
+    batch_size = int(args.bs)
+    confidence = float(args.confidence)
+    nms_thesh = float(args.nms_thresh)
+    start = 0
+
+    CUDA = torch.cuda.is_available()
+
+    num_classes = 80
+    classes = load_classes('data/coco.names') 
+
+    #Set up the neural network
+    print("Loading network.....")
+    model = Darknet(args.cfgfile)
+    model.load_weights(args.weightsfile)
+    print("Network successfully loaded")
+    
+    model.net_info["height"] = args.reso
+    inp_dim = int(model.net_info["height"])
+    assert inp_dim % 32 == 0 
+    assert inp_dim > 32
+
+    #If there's a GPU availible, put the model on GPU
+    if CUDA:
+        model.cuda()
+    
+    
+    #Set the model in evaluation mode
+    model.eval()
+    
+    read_dir = time.time()
+    #Detection phase
+    try:
+        imlist = [osp.join(osp.realpath('.'), images, img) for img in os.listdir(images) if os.path.splitext(img)[1] == '.png' or os.path.splitext(img)[1] =='.jpeg' or os.path.splitext(img)[1] =='.jpg']
+    except NotADirectoryError:
+        imlist = []
+        imlist.append(osp.join(osp.realpath('.'), images))
+    except FileNotFoundError:
+        print ("No file or directory with the name {}".format(images))
+        exit()
+        
+    if not os.path.exists(args.det):
+        os.makedirs(args.det)
+        
+    load_batch = time.time()
+    
+    batches = list(map(prep_image, imlist, [inp_dim for x in range(len(imlist))]))
+    im_batches = [x[0] for x in batches]
+    orig_ims = [x[1] for x in batches]
+    im_dim_list = [x[2] for x in batches]
+    im_dim_list = torch.FloatTensor(im_dim_list).repeat(1,2)
+    
+    
+    
+    if CUDA:
+        im_dim_list = im_dim_list.cuda()
+    
+    leftover = 0
+    
+    if (len(im_dim_list) % batch_size):
+        leftover = 1
+        
+        
+    if batch_size != 1:
+        num_batches = len(imlist) // batch_size + leftover            
+        im_batches = [torch.cat((im_batches[i*batch_size : min((i +  1)*batch_size,
+                            len(im_batches))]))  for i in range(num_batches)]        
+
+
+    i = 0
+    
+
+    write = False
+    model(get_test_input(inp_dim, CUDA), CUDA)
+    
+    start_det_loop = time.time()
+    
+    objs = {}
+    
+    
+    
+    for batch in im_batches:
+        #load the image 
+        start = time.time()
+        if CUDA:
+            batch = batch.cuda()
+        
+
+        #Apply offsets to the result predictions
+        #Tranform the predictions as described in the YOLO paper
+        #flatten the prediction vector 
+        # B x (bbox cord x no. of anchors) x grid_w x grid_h --> B x bbox x (all the boxes) 
+        # Put every proposed box as a row.
+        with torch.no_grad():
+            prediction = model(Variable(batch), CUDA)
+        
+#        prediction = prediction[:,scale_indices]
+
+        
+        #get the boxes with object confidence > threshold
+        #Convert the cordinates to absolute coordinates
+        #perform NMS on these boxes, and save the results 
+        #I could have done NMS and saving seperately to have a better abstraction
+        #But both these operations require looping, hence 
+        #clubbing these ops in one loop instead of two. 
+        #loops are slower than vectorised operations. 
+        
+        prediction = write_results(prediction, confidence, num_classes, nms = True, nms_conf = nms_thesh)
+        
+        
+        if type(prediction) == int:
+            i += 1
+            continue
+
+        end = time.time()
+        
+#        print(end - start)
+
+        prediction[:,0] += i*batch_size
+        
+        if not write:
+            output = prediction
+            write = 1
+        else:
+            output = torch.cat((output,prediction))
+            
+        
+        
+
+        for im_num, image in enumerate(imlist[i*batch_size: min((i +  1)*batch_size, len(imlist))]):
+            im_id = i*batch_size + im_num
+            objs = [classes[int(x[-1])] for x in output if int(x[0]) == im_id]
+            print("{0:20s} predicted in {1:6.3f} seconds".format(image.split("/")[-1], (end - start)/batch_size))
+            print("{0:20s} {1:s}".format("Objects Detected:", " ".join(objs)))
+            print("----------------------------------------------------------")
+        i += 1
+
+        
+        if CUDA:
+            torch.cuda.synchronize()
+    
+    try:
+        output
+    except NameError:
+        print("No detections were made")
+        exit()
+        
+    im_dim_list = torch.index_select(im_dim_list, 0, output[:,0].long())
+    
+    scaling_factor = torch.min(inp_dim/im_dim_list,1)[0].view(-1,1)
+    
+    
+    output[:,[1,3]] -= (inp_dim - scaling_factor*im_dim_list[:,0].view(-1,1))/2
+    output[:,[2,4]] -= (inp_dim - scaling_factor*im_dim_list[:,1].view(-1,1))/2
+    
+    
+    
+    output[:,1:5] /= scaling_factor
+    
+    for i in range(output.shape[0]):
+        output[i, [1,3]] = torch.clamp(output[i, [1,3]], 0.0, im_dim_list[i,0])
+        output[i, [2,4]] = torch.clamp(output[i, [2,4]], 0.0, im_dim_list[i,1])
+        
+        
+    output_recast = time.time()
+    
+    class_load = time.time()
+
+    colors = pkl.load(open("pallete", "rb"))
+    
+    draw = time.time()
+
+    def write(x, batches, results):
+        c1 = tuple(x[1:3].int())
+        c2 = tuple(x[3:5].int())
+        img = results[int(x[0])]
+
+        print( 'img' , int( x[0] ) )
+        print( 'cls' , int( x[-1] ) )
+
+        cls = int(x[-1])
+        label = "{0}".format(classes[cls])
+        color = random.choice(colors)
+        cv2.rectangle(img, c1, c2,color, 1)
+        t_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_PLAIN, 1 , 1)[0]
+        c2 = c1[0] + t_size[0] + 3, c1[1] + t_size[1] + 4
+        cv2.rectangle(img, c1, c2,color, -1)
+        cv2.putText(img, label, (c1[0], c1[1] + t_size[1] + 4), cv2.FONT_HERSHEY_PLAIN, 1, [225,255,255], 1)
+        return img
+    
+            
+    list(map(lambda x: write(x, im_batches, orig_ims), output))
+      
+    det_names = pd.Series(imlist).apply(lambda x: "{}/det_{}".format(args.det,x.split("/")[-1]))
+
+    print('det_names ',det_names)
+    print('orig_ims ',orig_ims[0].shape)
+    print('output : ',output)
+    
+    list(map(cv2.imwrite, det_names, orig_ims))
+    
+    end = time.time()
+    
+    print()
+    print("SUMMARY")
+    print("----------------------------------------------------------")
+    print("{:25s}: {}".format("Task", "Time Taken (in seconds)"))
+    print()
+    print("{:25s}: {:2.3f}".format("Reading addresses", load_batch - read_dir))
+    print("{:25s}: {:2.3f}".format("Loading batch", start_det_loop - load_batch))
+    print("{:25s}: {:2.3f}".format("Detection (" + str(len(imlist)) +  " images)", output_recast - start_det_loop))
+    print("{:25s}: {:2.3f}".format("Output Processing", class_load - output_recast))
+    print("{:25s}: {:2.3f}".format("Drawing Boxes", end - draw))
+    print("{:25s}: {:2.3f}".format("Average time_per_img", (end - load_batch)/len(imlist)))
+    print("----------------------------------------------------------")
+
+    
+    torch.cuda.empty_cache()

yolo/model.py

@@ -0,0 +1,189 @@
+from __future__ import division
+import time
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+import numpy as np
+import cv2
+from yolo.utils import *
+import argparse
+import os
+import os.path as osp
+from yolo.darknet import Darknet
+# from preprocess import prep_image, inp_to_image
+import pandas as pd
+import random
+import pickle as pkl
+import itertools
+import os
+import base64
+from PIL import Image
+from io import BytesIO
+
+class yolo_model():
+
+    
+    batch_size = int(1)
+    confidence = float(0.5)
+    nms_thesh = float(0.4)
+    reso = 416
+    start = 0
+
+    CUDA = torch.cuda.is_available()
+
+    num_classes = 80
+    
+
+    def __init__(self):
+
+        self.classes = load_classes( os.path.join( 'yolo' , 'data', 'coco.names' ) )
+
+        # self.colors = pkl.load( get_data_s3( "pallete" ) )
+
+        # Set up the neural network
+
+        self.model = Darknet( os.path.join( 'yolo' , 'yolov3-tiny.cfg' ) )
+        self.model.load_weights( os.path.join(  'yolo' , 'yolov3-tiny.weights' ) )
+        print(' [*] Model Loaded Successfuly')
+
+        # set model resolution
+
+        self.model.net_info["height"] = self.reso
+        self.inp_dim = int(self.model.net_info["height"])
+        
+        assert self.inp_dim % 32 == 0
+        assert self.inp_dim > 32
+
+        # If there's a GPU availible, put the model on GPU
+        if self.CUDA:
+            self.model.cuda()
+
+        # Set the model in evaluation mode
+        self.model.eval()
+
+    def write( self , x , batches , results , colors=[] ):
+        c1 = tuple(x[1:3].int())
+        c2 = tuple(x[3:5].int())
+        img = results[int(x[0])]
+
+        print( 'img' , int( x[0] ) )
+        print( 'cls' , int( x[-1] ) )
+
+        cls = int(x[-1])
+        label = "{0}".format(self.classes[cls])
+        color = random.choice(colors)
+        cv2.rectangle(img, c1, c2,color, 1)
+        t_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_PLAIN, 1 , 1)[0]
+        c2 = c1[0] + t_size[0] + 3, c1[1] + t_size[1] + 4
+        cv2.rectangle(img, c1, c2,color, -1)
+        cv2.putText(img, label, (c1[0], c1[1] + t_size[1] + 4), cv2.FONT_HERSHEY_PLAIN, 1, [225,255,255], 1)
+        return img
+
+    def img_to_base64_str(self,img):
+        buffered = BytesIO()
+        img.save(buffered, format="PNG")
+        buffered.seek(0)
+        img_byte = buffered.getvalue()
+        img_str = "data:image/png;base64," + base64.b64encode(img_byte).decode()
+        return img_str
+
+
+    def predict( self , image ):
+
+        imlist = []
+        imlist.append( image )
+
+        batches = list( map( prep_image_org , imlist , [ self.inp_dim for x in range( len(imlist) ) ] ) )
+        im_batches = [x[0] for x in batches]
+        orig_ims = [x[1] for x in batches]
+        im_dim_list = [x[2] for x in batches]
+
+        print( 'im_dim_list : ' , im_dim_list )
+
+        im_dim_list = torch.FloatTensor(im_dim_list).repeat(1,2)
+
+        if self.CUDA:
+            im_dim_list = im_dim_list.cuda()
+
+        print('im_batches' , len(im_batches))
+
+        batch = im_batches[0]
+
+        if self.CUDA:
+            batch = batch.cuda()
+
+
+        #Apply offsets to the result predictions
+        #Tranform the predictions as described in the YOLO paper
+        #flatten the prediction vector
+        # B x (bbox cord x no. of anchors) x grid_w x grid_h --> B x bbox x (all the boxes)
+        # Put every proposed box as a row.
+        with torch.no_grad():
+            prediction = self.model(Variable(batch), self.CUDA)
+
+    #        prediction = prediction[:,scale_indices]
+
+
+        #get the boxes with object confidence > threshold
+        #Convert the cordinates to absolute coordinates
+        #perform NMS on these boxes, and save the results
+        #I could have done NMS and saving seperately to have a better abstraction
+        #But both these operations require looping, hence
+        #clubbing these ops in one loop instead of two.
+        #loops are slower than vectorised operations.
+
+        prediction = write_results(prediction, self.confidence, self.num_classes, nms = True, nms_conf = self.nms_thesh)
+
+        end = time.time()
+
+        # print(end - start)
+
+        # prediction[:,0] += i*batch_size
+
+        output = prediction
+
+        # 1, 1, 1
+        # print( 'enumerate : ' , batch_size ,  len(imlist) , min( batch_size , len(imlist) ) )
+
+        for im_num, image in enumerate( imlist ):
+            im_id = im_num
+            objs = [self.classes[int(x[-1])] for x in output if int(x[0]) == im_id]
+            # print("{0:20s} predicted in {1:6.3f} seconds".format(image.split("/")[-1], (end - self.start)/self.batch_size))
+            print("{0:20s} {1:s}".format("Objects Detected:", " ".join(objs)))
+            print("----------------------------------------------------------")
+
+        im_dim_list = torch.index_select(im_dim_list, 0, output[:,0].long())
+
+        scaling_factor = torch.min(self.inp_dim/im_dim_list,1)[0].view(-1,1)
+
+        output[:,[1,3]] -= (self.inp_dim - scaling_factor*im_dim_list[:,0].view(-1,1))/2
+        output[:,[2,4]] -= (self.inp_dim - scaling_factor*im_dim_list[:,1].view(-1,1))/2
+
+        output[:,1:5] /= scaling_factor
+
+        for i in range(output.shape[0]):
+            output[i, [1,3]] = torch.clamp(output[i, [1,3]], 0.0, im_dim_list[i,0])
+            output[i, [2,4]] = torch.clamp(output[i, [2,4]], 0.0, im_dim_list[i,1])
+
+        colors = pkl.load( open( "yolo/pallete", "rb") )
+
+        list(map(lambda x: self.write( x , im_batches , orig_ims , colors=colors ) , output ) )
+
+        print('orig_ims : shape ',orig_ims[0].shape)
+        # print('orig_ims : ',orig_ims[0])
+
+        output_image = Image.fromarray(orig_ims[0])
+
+        img_str = self.img_to_base64_str(output_image)
+
+        # im_bytes = orig_ims[0].tobytes()
+        # im_b64 = base64.b64encode(im_bytes)
+
+        # im_b64 = im_b64.decode('utf-8')
+
+        # print( 'im_b64' , im_b64 )
+
+        payload = dict({ 'image' : img_str , 'objects' : objs })
+
+        return payload,output_image
+

yolo/sample.py

@@ -0,0 +1,77 @@
+
+import os
+import boto3
+from io import BytesIO , StringIO
+import pickle as pkl
+from utils import *
+
+def get_data_s3(filename):
+    
+    ACCESS_KEY = "AKIAUKUH7S3OIVOEIRWY"
+    SECRET_KEY = "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"
+    bucket = "root-models"
+
+    s3 = boto3.client( "s3" , aws_access_key_id=ACCESS_KEY , aws_secret_access_key=SECRET_KEY )
+    
+    response = s3.get_object(Bucket=bucket, Key=filename)
+    
+    data = BytesIO( response["Body"].read() )
+
+    return data
+
+
+def parse_cfg_url(filename='yolov3.cfg'):
+
+    data = get_data_s3(filename)
+
+    lines = data.getvalue().decode().rstrip().lstrip().split('\n')     #store the lines in a list
+    lines = [x.rstrip().lstrip() for x in lines]
+
+    lines = [x for x in lines if len(x) > 0] #get read of the empty lines 
+    lines = [x for x in lines if x[0] != '#']  
+    lines = [x.rstrip().lstrip() for x in lines]
+
+    
+    block = {}
+    blocks = []
+    
+    for line in lines:
+        # print('line:' , line)
+        if line[0] == "[":               #This marks the start of a new block
+            if len(block) != 0:
+                blocks.append(block)
+                block = {}
+            block["type"] = line[1:-1].rstrip()
+        else:
+            key,value = line.split("=")
+            block[key.rstrip()] = value.lstrip()
+    blocks.append(block)
+
+    # print('blocks : 2 ' , blocks )
+
+    return blocks
+
+if __name__ == '__main__':
+    # parse_cfg('yolov3.cfg')
+
+    # parse_cfg_url('yolov3.cfg')
+
+    # colors = pkl.load( open( "pallete", "rb") )
+
+    # print(colors)
+
+    # print()
+
+    # colors = pkl.load( get_data_s3( "pallete" ) )
+
+    # print(colors)
+
+    classes = load_classes('data/coco.names')
+
+    print( classes )
+
+    print()
+
+    classes = load_classes_url('coco.names')
+
+    print( classes )

yolo/test.py

@@ -0,0 +1,166 @@
+from __future__ import division
+import time
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+import numpy as np
+import cv2
+from utils import *
+import argparse
+import os
+import os.path as osp
+from darknet import Darknet
+# from preprocess import prep_image, inp_to_image
+import pandas as pd
+import random
+import pickle as pkl
+import itertools
+import os
+
+if __name__ == '__main__':
+
+    images = os.path.join('victoria.jpg')
+
+    batch_size = int(1)
+    confidence = float(0.5)
+    nms_thesh = float(0.4)
+    reso = 416
+    start = 0
+
+    CUDA = torch.cuda.is_available()
+
+    num_classes = 80
+    classes = load_classes('data/coco.names')
+
+    #Set up the neural network
+
+    model = Darknet("yolov3.cfg")
+    model.load_weights("yolov3.weights")
+    print(' [*] Model Loaded Successfuly')
+
+    # set model resolution
+
+    model.net_info["height"] = reso
+    inp_dim = int(model.net_info["height"])
+
+    assert inp_dim % 32 == 0
+    assert inp_dim > 32
+
+    # If there's a GPU availible, put the model on GPU
+    if CUDA:
+        model.cuda()
+
+    # Set the model in evaluation mode
+    model.eval()
+
+    imlist = []
+    imlist.append( osp.join(osp.realpath('.') , images) )
+
+    batches = list( map( prep_image , imlist , [ inp_dim for x in range( len(imlist) ) ] ) )
+    im_batches = [x[0] for x in batches]
+    orig_ims = [x[1] for x in batches]
+    im_dim_list = [x[2] for x in batches]
+
+    print( 'im_dim_list : ' , im_dim_list )
+
+    im_dim_list = torch.FloatTensor(im_dim_list).repeat(1,2)
+
+    print( 'im_dim_list : after' , im_dim_list )
+
+    if CUDA:
+        im_dim_list = im_dim_list.cuda()
+
+    print('im_batches' , len(im_batches))
+
+    batch = im_batches[0]
+
+    if CUDA:
+        batch = batch.cuda()
+
+
+    #Apply offsets to the result predictions
+    #Tranform the predictions as described in the YOLO paper
+    #flatten the prediction vector
+    # B x (bbox cord x no. of anchors) x grid_w x grid_h --> B x bbox x (all the boxes)
+    # Put every proposed box as a row.
+    with torch.no_grad():
+        prediction = model(Variable(batch), CUDA)
+
+#        prediction = prediction[:,scale_indices]
+
+
+    #get the boxes with object confidence > threshold
+    #Convert the cordinates to absolute coordinates
+    #perform NMS on these boxes, and save the results
+    #I could have done NMS and saving seperately to have a better abstraction
+    #But both these operations require looping, hence
+    #clubbing these ops in one loop instead of two.
+    #loops are slower than vectorised operations.
+
+    prediction = write_results(prediction, confidence, num_classes, nms = True, nms_conf = nms_thesh)
+
+
+    # if type(prediction) == int:
+    #     continue
+
+    end = time.time()
+
+    # print(end - start)
+
+    # prediction[:,0] += i*batch_size
+
+    output = prediction
+
+    # 1, 1, 1
+    # print( 'enumerate : ' , batch_size ,  len(imlist) , min( batch_size , len(imlist) ) )
+
+    for im_num, image in enumerate( imlist ):
+        im_id = im_num
+        objs = [classes[int(x[-1])] for x in output if int(x[0]) == im_id]
+        print("{0:20s} predicted in {1:6.3f} seconds".format(image.split("/")[-1], (end - start)/batch_size))
+        print("{0:20s} {1:s}".format("Objects Detected:", " ".join(objs)))
+        print("----------------------------------------------------------")
+
+    im_dim_list = torch.index_select(im_dim_list, 0, output[:,0].long())
+
+    scaling_factor = torch.min(inp_dim/im_dim_list,1)[0].view(-1,1)
+
+    output[:,[1,3]] -= (inp_dim - scaling_factor*im_dim_list[:,0].view(-1,1))/2
+    output[:,[2,4]] -= (inp_dim - scaling_factor*im_dim_list[:,1].view(-1,1))/2
+
+    output[:,1:5] /= scaling_factor
+
+    for i in range(output.shape[0]):
+        output[i, [1,3]] = torch.clamp(output[i, [1,3]], 0.0, im_dim_list[i,0])
+        output[i, [2,4]] = torch.clamp(output[i, [2,4]], 0.0, im_dim_list[i,1])
+
+    colors = pkl.load(open("pallete", "rb"))
+
+    def write(x, batches, results):
+        c1 = tuple(x[1:3].int())
+        c2 = tuple(x[3:5].int())
+        img = results[int(x[0])]
+
+        print( 'img' , int( x[0] ) )
+        print( 'cls' , int( x[-1] ) )
+
+        cls = int(x[-1])
+        label = "{0}".format(classes[cls])
+        color = random.choice(colors)
+        cv2.rectangle(img, c1, c2,color, 1)
+        t_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_PLAIN, 1 , 1)[0]
+        c2 = c1[0] + t_size[0] + 3, c1[1] + t_size[1] + 4
+        cv2.rectangle(img, c1, c2,color, -1)
+        cv2.putText(img, label, (c1[0], c1[1] + t_size[1] + 4), cv2.FONT_HERSHEY_PLAIN, 1, [225,255,255], 1)
+        return img
+
+
+    list(map(lambda x: write(x, im_batches, orig_ims), output))
+
+    det_names = pd.Series(imlist).apply(lambda x: "{}/det_{}".format('det',x.split("/")[-1]))
+
+    print('det_names ',det_names)
+    print('orig_ims ',orig_ims[0].shape)
+    print('output : ',output)
+
+    list(map(cv2.imwrite, det_names, orig_ims))

yolo/utils.py

@@ -0,0 +1,324 @@
+from __future__ import division
+
+import torch 
+import torch.nn as nn
+import torch.nn.functional as F 
+from torch.autograd import Variable
+import numpy as np
+import cv2 
+import boto3
+from io import BytesIO
+
+def get_data_s3(filename):
+    
+    ACCESS_KEY = "AKIAUKUH7S3OIVOEIRWY"
+    SECRET_KEY = "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"
+    bucket = "root-models"
+
+    s3 = boto3.client( "s3" , aws_access_key_id=ACCESS_KEY , aws_secret_access_key=SECRET_KEY )
+    
+    response = s3.get_object(Bucket=bucket, Key=filename)
+    
+    data = BytesIO( response["Body"].read() )
+
+    return data
+
+def parse_cfg_url(filename='yolov3.cfg'):
+
+    data = get_data_s3(filename)
+
+    lines = data.getvalue().decode().rstrip().lstrip().split('\n')     #store the lines in a list
+    lines = [x.rstrip().lstrip() for x in lines]
+
+    lines = [x for x in lines if len(x) > 0] #get read of the empty lines 
+    lines = [x for x in lines if x[0] != '#']  
+    lines = [x.rstrip().lstrip() for x in lines]
+
+    
+    block = {}
+    blocks = []
+    
+    for line in lines:
+        # print('line:' , line)
+        if line[0] == "[":               #This marks the start of a new block
+            if len(block) != 0:
+                blocks.append(block)
+                block = {}
+            block["type"] = line[1:-1].rstrip()
+        else:
+            key,value = line.split("=")
+            block[key.rstrip()] = value.lstrip()
+    blocks.append(block)
+
+    # print('blocks : 2 ' , blocks )
+
+    return blocks
+
+
+
+def predict_transform(prediction, inp_dim, anchors, num_classes, CUDA = True):
+    batch_size = prediction.size(0)
+    stride =  inp_dim // prediction.size(2)
+    grid_size = inp_dim // stride
+    bbox_attrs = 5 + num_classes
+    num_anchors = len(anchors)
+    
+    anchors = [(a[0]/stride, a[1]/stride) for a in anchors]
+
+
+
+    prediction = prediction.view(batch_size, bbox_attrs*num_anchors, grid_size*grid_size)
+    prediction = prediction.transpose(1,2).contiguous()
+    prediction = prediction.view(batch_size, grid_size*grid_size*num_anchors, bbox_attrs)
+
+
+    #Sigmoid the  centre_X, centre_Y. and object confidencce
+    prediction[:,:,0] = torch.sigmoid(prediction[:,:,0])
+    prediction[:,:,1] = torch.sigmoid(prediction[:,:,1])
+    prediction[:,:,4] = torch.sigmoid(prediction[:,:,4])
+    
+
+    
+    #Add the center offsets
+    grid_len = np.arange(grid_size)
+    a,b = np.meshgrid(grid_len, grid_len)
+    
+    x_offset = torch.FloatTensor(a).view(-1,1)
+    y_offset = torch.FloatTensor(b).view(-1,1)
+    
+    if CUDA:
+        x_offset = x_offset.cuda()
+        y_offset = y_offset.cuda()
+    
+    x_y_offset = torch.cat((x_offset, y_offset), 1).repeat(1,num_anchors).view(-1,2).unsqueeze(0)
+    
+    prediction[:,:,:2] += x_y_offset
+      
+    #log space transform height and the width
+    anchors = torch.FloatTensor(anchors)
+    
+    if CUDA:
+        anchors = anchors.cuda()
+    
+    anchors = anchors.repeat(grid_size*grid_size, 1).unsqueeze(0)
+    prediction[:,:,2:4] = torch.exp(prediction[:,:,2:4])*anchors
+
+    #Softmax the class scores
+    prediction[:,:,5: 5 + num_classes] = torch.sigmoid((prediction[:,:, 5 : 5 + num_classes]))
+
+    prediction[:,:,:4] *= stride
+   
+    
+    return prediction
+
+def write_results(prediction, confidence, num_classes, nms = True, nms_conf = 0.4):
+    conf_mask = (prediction[:,:,4] > confidence).float().unsqueeze(2)
+    prediction = prediction*conf_mask
+    
+
+    try:
+        ind_nz = torch.nonzero(prediction[:,:,4]).transpose(0,1).contiguous()
+    except:
+        return 0
+    
+    
+    box_a = prediction.new(prediction.shape)
+    box_a[:,:,0] = (prediction[:,:,0] - prediction[:,:,2]/2)
+    box_a[:,:,1] = (prediction[:,:,1] - prediction[:,:,3]/2)
+    box_a[:,:,2] = (prediction[:,:,0] + prediction[:,:,2]/2) 
+    box_a[:,:,3] = (prediction[:,:,1] + prediction[:,:,3]/2)
+    prediction[:,:,:4] = box_a[:,:,:4]
+    
+
+    
+    batch_size = prediction.size(0)
+    
+    output = prediction.new(1, prediction.size(2) + 1)
+    write = False
+
+
+    for ind in range(batch_size):
+        #select the image from the batch
+        image_pred = prediction[ind]
+        
+
+        
+        #Get the class having maximum score, and the index of that class
+        #Get rid of num_classes softmax scores 
+        #Add the class index and the class score of class having maximum score
+        max_conf, max_conf_score = torch.max(image_pred[:,5:5+ num_classes], 1)
+        max_conf = max_conf.float().unsqueeze(1)
+        max_conf_score = max_conf_score.float().unsqueeze(1)
+        seq = (image_pred[:,:5], max_conf, max_conf_score)
+        image_pred = torch.cat(seq, 1)
+        
+
+        
+        #Get rid of the zero entries
+        non_zero_ind =  (torch.nonzero(image_pred[:,4]))
+
+        
+        image_pred_ = image_pred[non_zero_ind.squeeze(),:].view(-1,7)
+        
+        #Get the various classes detected in the image
+        try:
+            img_classes = unique(image_pred_[:,-1])
+        except:
+             continue
+        #WE will do NMS classwise
+        for cls in img_classes:
+            #get the detections with one particular class
+            cls_mask = image_pred_*(image_pred_[:,-1] == cls).float().unsqueeze(1)
+            class_mask_ind = torch.nonzero(cls_mask[:,-2]).squeeze()
+            
+
+            image_pred_class = image_pred_[class_mask_ind].view(-1,7)
+
+		
+        
+             #sort the detections such that the entry with the maximum objectness
+             #confidence is at the top
+            conf_sort_index = torch.sort(image_pred_class[:,4], descending = True )[1]
+            image_pred_class = image_pred_class[conf_sort_index]
+            idx = image_pred_class.size(0)
+            
+            #if nms has to be done
+            if nms:
+                #For each detection
+                for i in range(idx):
+                    #Get the IOUs of all boxes that come after the one we are looking at 
+                    #in the loop
+                    try:
+                        ious = bbox_iou(image_pred_class[i].unsqueeze(0), image_pred_class[i+1:])
+                    except ValueError:
+                        break
+        
+                    except IndexError:
+                        break
+                    
+                    #Zero out all the detections that have IoU > treshhold
+                    iou_mask = (ious < nms_conf).float().unsqueeze(1)
+                    image_pred_class[i+1:] *= iou_mask       
+                    
+                    #Remove the non-zero entries
+                    non_zero_ind = torch.nonzero(image_pred_class[:,4]).squeeze()
+                    image_pred_class = image_pred_class[non_zero_ind].view(-1,7)
+                    
+                    
+
+            #Concatenate the batch_id of the image to the detection
+            #this helps us identify which image does the detection correspond to 
+            #We use a linear straucture to hold ALL the detections from the batch
+            #the batch_dim is flattened
+            #batch is identified by extra batch column
+            
+            
+            batch_ind = image_pred_class.new(image_pred_class.size(0), 1).fill_(ind)
+            seq = batch_ind, image_pred_class
+            if not write:
+                output = torch.cat(seq,1)
+                write = True
+            else:
+                out = torch.cat(seq,1)
+                output = torch.cat((output,out))
+    
+    try:
+        return output
+    except:
+        return 0
+
+def unique(tensor):
+    tensor_np = tensor.cpu().numpy()
+    unique_np = np.unique(tensor_np)
+    unique_tensor = torch.from_numpy(unique_np)
+    
+    tensor_res = tensor.new(unique_tensor.shape)
+    tensor_res.copy_(unique_tensor)
+    return tensor_res
+
+def load_classes_url(namesfile):
+    fp = get_data_s3(namesfile)
+    names = fp.getvalue().decode().split("\n")[:-1]
+    return names
+
+
+def load_classes(namesfile):
+    fp = open(namesfile, "r")
+    names = fp.read().split("\n")[:-1]
+    return names
+
+def bbox_iou(box1, box2):
+    """
+    Returns the IoU of two bounding boxes 
+    
+    
+    """
+    #Get the coordinates of bounding boxes
+    b1_x1, b1_y1, b1_x2, b1_y2 = box1[:,0], box1[:,1], box1[:,2], box1[:,3]
+    b2_x1, b2_y1, b2_x2, b2_y2 = box2[:,0], box2[:,1], box2[:,2], box2[:,3]
+    
+    #get the corrdinates of the intersection rectangle
+    inter_rect_x1 =  torch.max(b1_x1, b2_x1)
+    inter_rect_y1 =  torch.max(b1_y1, b2_y1)
+    inter_rect_x2 =  torch.min(b1_x2, b2_x2)
+    inter_rect_y2 =  torch.min(b1_y2, b2_y2)
+    
+    #Intersection area
+    if torch.cuda.is_available():
+            inter_area = torch.max(inter_rect_x2 - inter_rect_x1 + 1,torch.zeros(inter_rect_x2.shape).cuda())*torch.max(inter_rect_y2 - inter_rect_y1 + 1, torch.zeros(inter_rect_x2.shape).cuda())
+    else:
+            inter_area = torch.max(inter_rect_x2 - inter_rect_x1 + 1,torch.zeros(inter_rect_x2.shape))*torch.max(inter_rect_y2 - inter_rect_y1 + 1, torch.zeros(inter_rect_x2.shape))
+    
+    #Union Area
+    b1_area = (b1_x2 - b1_x1 + 1)*(b1_y2 - b1_y1 + 1)
+    b2_area = (b2_x2 - b2_x1 + 1)*(b2_y2 - b2_y1 + 1)
+    
+    iou = inter_area / (b1_area + b2_area - inter_area)
+    
+    return iou
+
+def letterbox_image(img, inp_dim):
+    '''resize image with unchanged aspect ratio using padding'''
+    img_w, img_h = img.shape[1], img.shape[0]
+    w, h = inp_dim
+    new_w = int(img_w * min(w/img_w, h/img_h))
+    new_h = int(img_h * min(w/img_w, h/img_h))
+    resized_image = cv2.resize(img, (new_w,new_h), interpolation = cv2.INTER_CUBIC)
+    
+    canvas = np.full((inp_dim[1], inp_dim[0], 3), 128)
+
+    canvas[(h-new_h)//2:(h-new_h)//2 + new_h,(w-new_w)//2:(w-new_w)//2 + new_w,  :] = resized_image
+    
+    return canvas
+
+
+def prep_image_org(orig_im, inp_dim):
+    """
+    Prepare image for inputting to the neural network. 
+    
+    Returns a Variable 
+    """
+
+    # orig_im = cv2.imread(img)
+    dim = orig_im.shape[1], orig_im.shape[0]
+    img = (letterbox_image(orig_im, (inp_dim, inp_dim)))
+    img_ = img[:,:,::-1].transpose((2,0,1)).copy()
+    img_ = torch.from_numpy(img_).float().div(255.0).unsqueeze(0)
+    return img_, orig_im, dim
+
+
+
+def prep_image(img, inp_dim):
+    """
+    Prepare image for inputting to the neural network. 
+    
+    Returns a Variable 
+    """
+
+    orig_im = cv2.imread(img)
+    dim = orig_im.shape[1], orig_im.shape[0]
+    img = (letterbox_image(orig_im, (inp_dim, inp_dim)))
+    img_ = img[:,:,::-1].transpose((2,0,1)).copy()
+    img_ = torch.from_numpy(img_).float().div(255.0).unsqueeze(0)
+    return img_, orig_im, dim
+

yolo/yolov3-tiny.cfg

@@ -0,0 +1,182 @@
+[net]
+# Testing
+batch=1
+subdivisions=1
+# Training
+# batch=64
+# subdivisions=2
+width=416
+height=416
+channels=3
+momentum=0.9
+decay=0.0005
+angle=0
+saturation = 1.5
+exposure = 1.5
+hue=.1
+
+learning_rate=0.001
+burn_in=1000
+max_batches = 500200
+policy=steps
+steps=400000,450000
+scales=.1,.1
+
+[convolutional]
+batch_normalize=1
+filters=16
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[maxpool]
+size=2
+stride=2
+
+[convolutional]
+batch_normalize=1
+filters=32
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[maxpool]
+size=2
+stride=2
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[maxpool]
+size=2
+stride=2
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[maxpool]
+size=2
+stride=2
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[maxpool]
+size=2
+stride=2
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[maxpool]
+size=2
+stride=1
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=1
+pad=1
+activation=leaky
+
+###########
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+
+
+[yolo]
+mask = 3,4,5
+anchors = 10,14,  23,27,  37,58,  81,82,  135,169,  344,319
+classes=80
+num=6
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+random=1
+
+[route]
+layers = -4
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[upsample]
+stride=2
+
+[route]
+layers = -1, 8
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+[yolo]
+mask = 0,1,2
+anchors = 10,14,  23,27,  37,58,  81,82,  135,169,  344,319
+classes=80
+num=6
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+random=1

yolo/yolov3-tiny.weights

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

yolo/yolov3.cfg

@@ -0,0 +1,788 @@
+[net]
+# Testing
+# batch=1
+# subdivisions=1
+# Training
+batch=64
+subdivisions=16
+width=624
+height=624
+channels=3
+momentum=0.9
+decay=0.0005
+angle=0
+saturation = 1.5
+exposure = 1.5
+hue=.1
+
+learning_rate=0.001
+burn_in=1000
+max_batches = 500200
+policy=steps
+steps=400000,450000
+scales=.1,.1
+
+[convolutional]
+batch_normalize=1
+filters=32
+size=3
+stride=1
+pad=1
+activation=leaky
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=3
+stride=2
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=32
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=2
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=2
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=2
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=2
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[shortcut]
+from=-3
+activation=linear
+
+######################
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=1024
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=1024
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=1024
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+
+[yolo]
+mask = 6,7,8
+anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
+classes=80
+num=9
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+random=1
+
+
+[route]
+layers = -4
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[upsample]
+stride=2
+
+[route]
+layers = -1, 61
+
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=512
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=512
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=512
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+
+[yolo]
+mask = 3,4,5
+anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
+classes=80
+num=9
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+random=1
+
+
+
+[route]
+layers = -4
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[upsample]
+stride=2
+
+[route]
+layers = -1, 36
+
+
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=256
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=256
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=256
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+
+[yolo]
+mask = 0,1,2
+anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
+classes=80
+num=9
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+random=1