41

new

.gitattributes

@@ -33,3 +33,6 @@ 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
+traffic-light-management-using-AI-main/traffic-light-management-using-AI-main/images/intersection.jpg filter=lfs diff=lfs merge=lfs -text
+traffic-light-management-using-AI-main/traffic-light-management-using-AI-main/images/mod_int.png filter=lfs diff=lfs merge=lfs -text
+yolov3-320.weights filter=lfs diff=lfs merge=lfs -text

traffic-light-management-using-AI-main/traffic-light-management-using-AI-main/README.md

@@ -0,0 +1,52 @@
+# Traffic-light-management-using-AI
+Despite the fact that computer vision is today a highly developed field, capabilities for recognition and classification are not frequently used in day-to-day activities. Therefore, in this project we will make use of the current traffic infrastructure with some additional requirements, to create and demonstrate an advanced traffic light management
+# Abstract
+Increasing traffic congestion at signalized junctions is a matter of great concern for creating and maintaining sustainable cities. Traffic jams in addition to adding to drivers' delays and stress levels, traffic bottlenecks significantly increase fuel usage and pollution. The main reason behind this is the way of controlling traffic at such junctions. Semi-automated and conventional traffic management has reached it’s saturation point and can no longer handle the high density of traffic flow with complex patterns. In this paper, we discuss and draw comparisons of previous research and works done to solve this problem. Our focus would be on techniques using Machine Learning, such as Computer Vision and Deep Neural Networks.
+# Introduction
+Numerous road networks are experiencing issues due to the decline in road capacity and the accompanying Level of Service as a result of the rise in automobiles in metropolitan areas. The bottleneck for these high vehicular flow are the conventional traffic management system used in these cities. There are two ways to tackle traffic flow currently in implementation : semi-automatic traffic lights with fixed timings or traffic police stationed at junctions to control the flow manually. The problem with use of traffic lights is that they use a fixed time for each side of the cross road, irrespective of the density of vehicles on those roads.
+
+![image](https://user-images.githubusercontent.com/75363378/207390161-76e0fa64-9982-49e7-8f3c-874404b94fe5.png)
+![image](https://user-images.githubusercontent.com/75363378/207390225-02272ba4-38c9-48a2-b05b-3e329a4a6589.png)
+
+Ideally, the road with higher density of vehicles should be given extra time to pass the junction, as that will lead to lower waiting time on average for all of the vehicles. Depending on manual control of traffic at junctions with manpower is inefficient, as a human cannot process all of the information at live with great accuracy for a longer time. Despite the fact that computer vision is today a highly developed field, capabilities for recognition and classification are not frequently used in day-to-day activities. Therefore, in this project we will be using Machine Vision to improve the current state of traffic. We would also come across some new methodology and techniques in analysis and decision making for traffic lights using live cameras installed at junctions.
+# Problem Statement
+To build a self adaptive traffic light control system based on YOLO. Disproportionate and diverse traffic in different lanes leads to inefficient utilization of same time slot for each of them characterized by slower speeds, longer trip times, and increased vehicular queuing.To create a system which enable the traffic management system to take time allocation decisions for a particular lane according to the traffic density on other different lanes with the help of cameras, image processing modules.
+# Methodology
+The solution can be explained in four simple steps:
+1.	Get a real time image of each lane.
+2.	Scan and determine traffic density.
+3.	Input this data to the Time Allocation module.
+4.	The output will be the time slots for each lane, accordingly.
+
+ <img src="https://user-images.githubusercontent.com/75363378/207391460-a103d439-ec6b-460f-a7b7-acddeb8c42a2.png" height="500">  <img src="https://user-images.githubusercontent.com/75363378/207391504-bf55def6-0644-4673-99ba-233f63f3c63b.png" width="500" height="500">
+
+# Results and Discussions
+The result for the project could be divided in two divisions : 
+
+1.	Evaluation of Vehicle Detection Model
+		The vehicle detection module was tested with a variety of test images containing varying amounts of vehicles, and the accuracy of detection was found to be in the  		range of 75-80%. Some test results are shown above in Fig. 3. This is satisfactory, but not optimum. The primary reason for low  accuracy is the lack of a proper 		dataset. To improve upon this, real-life footage from traffic cameras can be used to train the model, so that accuracy of the system can be improved.
+		We have used the images from the live feed camera installed at the traffic junctions or at normal traffic spots around the city or on the outskirts. These videos 		or live feeds were  used to feed the model based on YOLO and OpenCV, where we detected the vehicle and there movement as in downwards or upwards, i.e., towards the 		traffic signal or away from it. We were also successful in defining what type of vehicle is it.
+		
+    <img src="https://user-images.githubusercontent.com/75363378/207393722-8678178d-4ca3-41d3-a8ab-ffc61a123f9a.png" width="800" height="550">
+    <img src="https://user-images.githubusercontent.com/75363378/207393802-b3c7df30-5a11-48f0-baf0-838395017fe3.png" width="800" height="550">
+
+    We were also succesfull in implementing the derived traffic density from the detection module to the model for finding the optimum timings for each traffic lane to 		pass the vehicles. This was done on the principle of giving more priority or giving more time to the lane with higher traffic density and lesser to the ones with 		relatively uncrowded lane, while not creating bottlenecks or congestion in any one lane. For the same purpose,  we created a simple simulation using PyGame.
+		
+    <img src="https://user-images.githubusercontent.com/75363378/207395269-acc46692-6cd3-4391-b262-17749ada0868.png" width="800" height="550">
+
+		
+2.	Evaluation of the Proposed Adaptive System
+		For the pupose of evaluation of the system, the traffic movement simulation for both the system was run for 5 minutes a total of 15 times, using which the total 			number of vehicles that were able to pass through this junction were calculated.
+		
+    <img src="https://user-images.githubusercontent.com/75363378/207395478-a0ceec2b-21e0-4954-aa3d-732d7bd51bd4.png" width="500">
+		
+# References
+[1] <a href="https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=9358334&isnumber=9358272">M. M. Gandhi, D. S. Solanki, R. S. Daptardar and N. S. Baloorkar, "Smart Control of Traffic Light Using Artificial Intelligence," 2020 5th IEEE International Conference on Recent Advances and Innovations in Engineering (ICRAIE), 2020, pp. 1-6, doi: 10.1109/ICRAIE51050.2020.9358334.</a>
+
+[2] <a href="https://www.researchgate.net/publication/229029935_Intelligent_Traffic_Lights_Control_By_Fuzzy_Logic">Khiang, Kok & Khalid, Marzuki & Yusof, Rubiyah. (1997). Intelligent Traffic Lights Control By Fuzzy Logic. Malaysian Journal of Computer Science. 9. 29-35.</a>
+
+[3] <a href="https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=6137134&isnumber=6137119">M. H. Malhi, M. H. Aslam, F. Saeed, O. Javed and M. Fraz, "Vision Based Intelligent Traffic Management System," 2011 Frontiers of Information Technology, 2011, pp. 137-141, doi: 10.1109/FIT.2011.33.</a>
+
+[4] <a href="https://www.researchgate.net/publication/328987822_Improving_Traffic_Light_Control_by_Means_of_Fuzzy_Logic">A. Vogel, I. Oremović, R. Šimić and E. Ivanjko, "Improving Traffic Light Control by Means of Fuzzy Logic," 2018 International Symposium ELMAR, 2018, pp. 51-56, doi: 10.23919/ELMAR.2018.8534692.</a>
+
+[5] <a href="https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=7868350&isnumber=7868337">T. Osman, S. S. Psyche, J. M. Shafi Ferdous and H. U. Zaman, "Intelligent traffic management system for cross section of roads using computer vision," 2017 IEEE 7th Annual Computing and Communication Workshop and Conference (CCWC), 2017, pp. 1-7, doi: 10.1109/CCWC.2017.7868350.</a>

traffic-light-management-using-AI-main/traffic-light-management-using-AI-main/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

traffic-light-management-using-AI-main/traffic-light-management-using-AI-main/data.csv

@@ -0,0 +1,3 @@
+Direction,car,motorbike,bus,truck
+Up,20,0,2,0
+Down,5,3,2,1

traffic-light-management-using-AI-main/traffic-light-management-using-AI-main/requirements.txt

@@ -0,0 +1 @@
+Download the YoloV3 weights file from here : https://drive.google.com/file/d/1RuNsdS9MgumwTFwVqI9rwSQJwk8qSAQS/view?usp=sharing

traffic-light-management-using-AI-main/traffic-light-management-using-AI-main/simulation.py

@@ -0,0 +1,511 @@
+# LAG
+# NO. OF VEHICLES IN SIGNAL CLASS
+# stops not used
+# DISTRIBUTION
+# BUS TOUCHING ON TURNS
+# Distribution using python class
+
+# *** IMAGE XY COOD IS TOP LEFT
+import random
+import math
+import time
+import threading
+# from vehicle_detection import detection
+import pygame
+import sys
+import os
+
+# options={
+#    'model':'./cfg/yolo.cfg',     #specifying the path of model
+#    'load':'./bin/yolov2.weights',   #weights
+#    'threshold':0.3     #minimum confidence factor to create a box, greater than 0.3 good
+# }
+
+# tfnet=TFNet(options)    #READ ABOUT TFNET
+
+# Default values of signal times
+defaultRed = 150
+defaultYellow = 5
+defaultGreen = 20
+defaultMinimum = 10
+defaultMaximum = 60
+
+signals = []
+noOfSignals = 4
+simTime = 300       # change this to change time of simulation
+timeElapsed = 0
+
+currentGreen = 0   # Indicates which signal is green
+nextGreen = (currentGreen+1)%noOfSignals
+currentYellow = 0   # Indicates whether yellow signal is on or off 
+
+# Average times for vehicles to pass the intersection
+carTime = 2
+bikeTime = 1
+busTime = 2.5
+truckTime = 2.5
+
+# Count of cars at a traffic signal
+noOfCars = 0
+noOfBikes = 0
+noOfBuses = 0
+noOfTrucks = 0
+noOfLanes = 2
+
+# Red signal time at which cars will be detected at a signal
+detectionTime = 5
+
+speeds = {'car': 2.25, 'bus': 1.8, 'truck': 1.8, 'bike': 2.5}  # average speeds of vehicles
+
+# Coordinates of start
+x = {'right':[0,0,0], 'down':[755,727,697], 'left':[1400,1400,1400], 'up':[602,627,657]}    
+y = {'right':[348,370,398], 'down':[0,0,0], 'left':[498,466,436], 'up':[800,800,800]}
+
+vehicles = {'right': {0:[], 1:[], 2:[], 'crossed':0}, 'down': {0:[], 1:[], 2:[], 'crossed':0}, 'left': {0:[], 1:[], 2:[], 'crossed':0}, 'up': {0:[], 1:[], 2:[], 'crossed':0}}
+vehicleTypes = {0: 'car', 1: 'bus', 2: 'truck', 3: 'bike'}
+directionNumbers = {0:'right', 1:'down', 2:'left', 3:'up'}
+
+# Coordinates of signal image, timer, and vehicle count
+signalCoods = [(530,230),(810,230),(810,570),(530,570)]
+signalTimerCoods = [(530,210),(810,210),(810,550),(530,550)]
+vehicleCountCoods = [(480,210),(880,210),(880,550),(480,550)]
+vehicleCountTexts = ["0", "0", "0", "0"]
+
+# Coordinates of stop lines
+stopLines = {'right': 590, 'down': 330, 'left': 800, 'up': 535}
+defaultStop = {'right': 580, 'down': 320, 'left': 810, 'up': 545}
+stops = {'right': [580,580,580], 'down': [320,320,320], 'left': [810,810,810], 'up': [545,545,545]}
+
+mid = {'right': {'x':705, 'y':445}, 'down': {'x':695, 'y':450}, 'left': {'x':695, 'y':425}, 'up': {'x':695, 'y':400}}
+rotationAngle = 3
+
+# Gap between vehicles
+gap = 15    # stopping gap
+gap2 = 15   # moving gap
+
+pygame.init()
+simulation = pygame.sprite.Group()
+
+class TrafficSignal:
+    def __init__(self, red, yellow, green, minimum, maximum):
+        self.red = red
+        self.yellow = yellow
+        self.green = green
+        self.minimum = minimum
+        self.maximum = maximum
+        self.signalText = "30"
+        self.totalGreenTime = 0
+        
+class Vehicle(pygame.sprite.Sprite):
+    def __init__(self, lane, vehicleClass, direction_number, direction, will_turn):
+        pygame.sprite.Sprite.__init__(self)
+        self.lane = lane
+        self.vehicleClass = vehicleClass
+        self.speed = speeds[vehicleClass]
+        self.direction_number = direction_number
+        self.direction = direction
+        self.x = x[direction][lane]
+        self.y = y[direction][lane]
+        self.crossed = 0
+        self.willTurn = will_turn
+        self.turned = 0
+        self.rotateAngle = 0
+        vehicles[direction][lane].append(self)
+        # self.stop = stops[direction][lane]
+        self.index = len(vehicles[direction][lane]) - 1
+        path = "images/" + direction + "/" + vehicleClass + ".png"
+        self.originalImage = pygame.image.load(path)
+        self.currentImage = pygame.image.load(path)
+
+    
+        if(direction=='right'):
+            if(len(vehicles[direction][lane])>1 and vehicles[direction][lane][self.index-1].crossed==0):    # if more than 1 vehicle in the lane of vehicle before it has crossed stop line
+                self.stop = vehicles[direction][lane][self.index-1].stop - vehicles[direction][lane][self.index-1].currentImage.get_rect().width - gap         # setting stop coordinate as: stop coordinate of next vehicle - width of next vehicle - gap
+            else:
+                self.stop = defaultStop[direction]
+            # Set new starting and stopping coordinate
+            temp = self.currentImage.get_rect().width + gap    
+            x[direction][lane] -= temp
+            stops[direction][lane] -= temp
+        elif(direction=='left'):
+            if(len(vehicles[direction][lane])>1 and vehicles[direction][lane][self.index-1].crossed==0):
+                self.stop = vehicles[direction][lane][self.index-1].stop + vehicles[direction][lane][self.index-1].currentImage.get_rect().width + gap
+            else:
+                self.stop = defaultStop[direction]
+            temp = self.currentImage.get_rect().width + gap
+            x[direction][lane] += temp
+            stops[direction][lane] += temp
+        elif(direction=='down'):
+            if(len(vehicles[direction][lane])>1 and vehicles[direction][lane][self.index-1].crossed==0):
+                self.stop = vehicles[direction][lane][self.index-1].stop - vehicles[direction][lane][self.index-1].currentImage.get_rect().height - gap
+            else:
+                self.stop = defaultStop[direction]
+            temp = self.currentImage.get_rect().height + gap
+            y[direction][lane] -= temp
+            stops[direction][lane] -= temp
+        elif(direction=='up'):
+            if(len(vehicles[direction][lane])>1 and vehicles[direction][lane][self.index-1].crossed==0):
+                self.stop = vehicles[direction][lane][self.index-1].stop + vehicles[direction][lane][self.index-1].currentImage.get_rect().height + gap
+            else:
+                self.stop = defaultStop[direction]
+            temp = self.currentImage.get_rect().height + gap
+            y[direction][lane] += temp
+            stops[direction][lane] += temp
+        simulation.add(self)
+
+    def render(self, screen):
+        screen.blit(self.currentImage, (self.x, self.y))
+
+    def move(self):
+        if(self.direction=='right'):
+            if(self.crossed==0 and self.x+self.currentImage.get_rect().width>stopLines[self.direction]):   # if the image has crossed stop line now
+                self.crossed = 1
+                vehicles[self.direction]['crossed'] += 1
+            if(self.willTurn==1):
+                if(self.crossed==0 or self.x+self.currentImage.get_rect().width<mid[self.direction]['x']):
+                    if((self.x+self.currentImage.get_rect().width<=self.stop or (currentGreen==0 and currentYellow==0) or self.crossed==1) and (self.index==0 or self.x+self.currentImage.get_rect().width<(vehicles[self.direction][self.lane][self.index-1].x - gap2) or vehicles[self.direction][self.lane][self.index-1].turned==1)):                
+                        self.x += self.speed
+                else:   
+                    if(self.turned==0):
+                        self.rotateAngle += rotationAngle
+                        self.currentImage = pygame.transform.rotate(self.originalImage, -self.rotateAngle)
+                        self.x += 2
+                        self.y += 1.8
+                        if(self.rotateAngle==90):
+                            self.turned = 1
+                            # path = "images/" + directionNumbers[((self.direction_number+1)%noOfSignals)] + "/" + self.vehicleClass + ".png"
+                            # self.x = mid[self.direction]['x']
+                            # self.y = mid[self.direction]['y']
+                            # self.image = pygame.image.load(path)
+                    else:
+                        if(self.index==0 or self.y+self.currentImage.get_rect().height<(vehicles[self.direction][self.lane][self.index-1].y - gap2) or self.x+self.currentImage.get_rect().width<(vehicles[self.direction][self.lane][self.index-1].x - gap2)):
+                            self.y += self.speed
+            else: 
+                if((self.x+self.currentImage.get_rect().width<=self.stop or self.crossed == 1 or (currentGreen==0 and currentYellow==0)) and (self.index==0 or self.x+self.currentImage.get_rect().width<(vehicles[self.direction][self.lane][self.index-1].x - gap2) or (vehicles[self.direction][self.lane][self.index-1].turned==1))):                
+                # (if the image has not reached its stop coordinate or has crossed stop line or has green signal) and (it is either the first vehicle in that lane or it is has enough gap to the next vehicle in that lane)
+                    self.x += self.speed  # move the vehicle
+
+
+
+        elif(self.direction=='down'):
+            if(self.crossed==0 and self.y+self.currentImage.get_rect().height>stopLines[self.direction]):
+                self.crossed = 1
+                vehicles[self.direction]['crossed'] += 1
+            if(self.willTurn==1):
+                if(self.crossed==0 or self.y+self.currentImage.get_rect().height<mid[self.direction]['y']):
+                    if((self.y+self.currentImage.get_rect().height<=self.stop or (currentGreen==1 and currentYellow==0) or self.crossed==1) and (self.index==0 or self.y+self.currentImage.get_rect().height<(vehicles[self.direction][self.lane][self.index-1].y - gap2) or vehicles[self.direction][self.lane][self.index-1].turned==1)):                
+                        self.y += self.speed
+                else:   
+                    if(self.turned==0):
+                        self.rotateAngle += rotationAngle
+                        self.currentImage = pygame.transform.rotate(self.originalImage, -self.rotateAngle)
+                        self.x -= 2.5
+                        self.y += 2
+                        if(self.rotateAngle==90):
+                            self.turned = 1
+                    else:
+                        if(self.index==0 or self.x>(vehicles[self.direction][self.lane][self.index-1].x + vehicles[self.direction][self.lane][self.index-1].currentImage.get_rect().width + gap2) or self.y<(vehicles[self.direction][self.lane][self.index-1].y - gap2)):
+                            self.x -= self.speed
+            else: 
+                if((self.y+self.currentImage.get_rect().height<=self.stop or self.crossed == 1 or (currentGreen==1 and currentYellow==0)) and (self.index==0 or self.y+self.currentImage.get_rect().height<(vehicles[self.direction][self.lane][self.index-1].y - gap2) or (vehicles[self.direction][self.lane][self.index-1].turned==1))):                
+                    self.y += self.speed
+            
+        elif(self.direction=='left'):
+            if(self.crossed==0 and self.x<stopLines[self.direction]):
+                self.crossed = 1
+                vehicles[self.direction]['crossed'] += 1
+            if(self.willTurn==1):
+                if(self.crossed==0 or self.x>mid[self.direction]['x']):
+                    if((self.x>=self.stop or (currentGreen==2 and currentYellow==0) or self.crossed==1) and (self.index==0 or self.x>(vehicles[self.direction][self.lane][self.index-1].x + vehicles[self.direction][self.lane][self.index-1].currentImage.get_rect().width + gap2) or vehicles[self.direction][self.lane][self.index-1].turned==1)):                
+                        self.x -= self.speed
+                else: 
+                    if(self.turned==0):
+                        self.rotateAngle += rotationAngle
+                        self.currentImage = pygame.transform.rotate(self.originalImage, -self.rotateAngle)
+                        self.x -= 1.8
+                        self.y -= 2.5
+                        if(self.rotateAngle==90):
+                            self.turned = 1
+                            # path = "images/" + directionNumbers[((self.direction_number+1)%noOfSignals)] + "/" + self.vehicleClass + ".png"
+                            # self.x = mid[self.direction]['x']
+                            # self.y = mid[self.direction]['y']
+                            # self.currentImage = pygame.image.load(path)
+                    else:
+                        if(self.index==0 or self.y>(vehicles[self.direction][self.lane][self.index-1].y + vehicles[self.direction][self.lane][self.index-1].currentImage.get_rect().height +  gap2) or self.x>(vehicles[self.direction][self.lane][self.index-1].x + gap2)):
+                            self.y -= self.speed
+            else: 
+                if((self.x>=self.stop or self.crossed == 1 or (currentGreen==2 and currentYellow==0)) and (self.index==0 or self.x>(vehicles[self.direction][self.lane][self.index-1].x + vehicles[self.direction][self.lane][self.index-1].currentImage.get_rect().width + gap2) or (vehicles[self.direction][self.lane][self.index-1].turned==1))):                
+                # (if the image has not reached its stop coordinate or has crossed stop line or has green signal) and (it is either the first vehicle in that lane or it is has enough gap to the next vehicle in that lane)
+                    self.x -= self.speed  # move the vehicle    
+            # if((self.x>=self.stop or self.crossed == 1 or (currentGreen==2 and currentYellow==0)) and (self.index==0 or self.x>(vehicles[self.direction][self.lane][self.index-1].x + vehicles[self.direction][self.lane][self.index-1].currentImage.get_rect().width + gap2))):                
+            #     self.x -= self.speed
+        elif(self.direction=='up'):
+            if(self.crossed==0 and self.y<stopLines[self.direction]):
+                self.crossed = 1
+                vehicles[self.direction]['crossed'] += 1
+            if(self.willTurn==1):
+                if(self.crossed==0 or self.y>mid[self.direction]['y']):
+                    if((self.y>=self.stop or (currentGreen==3 and currentYellow==0) or self.crossed == 1) and (self.index==0 or self.y>(vehicles[self.direction][self.lane][self.index-1].y + vehicles[self.direction][self.lane][self.index-1].currentImage.get_rect().height +  gap2) or vehicles[self.direction][self.lane][self.index-1].turned==1)):
+                        self.y -= self.speed
+                else:   
+                    if(self.turned==0):
+                        self.rotateAngle += rotationAngle
+                        self.currentImage = pygame.transform.rotate(self.originalImage, -self.rotateAngle)
+                        self.x += 1
+                        self.y -= 1
+                        if(self.rotateAngle==90):
+                            self.turned = 1
+                    else:
+                        if(self.index==0 or self.x<(vehicles[self.direction][self.lane][self.index-1].x - vehicles[self.direction][self.lane][self.index-1].currentImage.get_rect().width - gap2) or self.y>(vehicles[self.direction][self.lane][self.index-1].y + gap2)):
+                            self.x += self.speed
+            else: 
+                if((self.y>=self.stop or self.crossed == 1 or (currentGreen==3 and currentYellow==0)) and (self.index==0 or self.y>(vehicles[self.direction][self.lane][self.index-1].y + vehicles[self.direction][self.lane][self.index-1].currentImage.get_rect().height + gap2) or (vehicles[self.direction][self.lane][self.index-1].turned==1))):                
+                    self.y -= self.speed
+
+# Initialization of signals with default values
+def initialize():
+    ts1 = TrafficSignal(0, defaultYellow, defaultGreen, defaultMinimum, defaultMaximum)
+    signals.append(ts1)
+    ts2 = TrafficSignal(ts1.red+ts1.yellow+ts1.green, defaultYellow, defaultGreen, defaultMinimum, defaultMaximum)
+    signals.append(ts2)
+    ts3 = TrafficSignal(defaultRed, defaultYellow, defaultGreen, defaultMinimum, defaultMaximum)
+    signals.append(ts3)
+    ts4 = TrafficSignal(defaultRed, defaultYellow, defaultGreen, defaultMinimum, defaultMaximum)
+    signals.append(ts4)
+    repeat()
+
+# Set time according to formula
+def setTime():
+    global noOfCars, noOfBikes, noOfBuses, noOfTrucks, noOfLanes
+    global carTime, busTime, truckTime, bikeTime
+    os.system("say detecting vehicles, "+directionNumbers[(currentGreen+1)%noOfSignals])
+#    detection_result=detection(currentGreen,tfnet)
+#    greenTime = math.ceil(((noOfCars*carTime) + (noOfBuses*busTime) + (noOfBikes*bikeTime))/(noOfLanes+1))
+#    if(greenTime<defaultMinimum):
+#       greenTime = defaultMinimum
+#    elif(greenTime>defaultMaximum):
+#       greenTime = defaultMaximum
+    # greenTime = len(vehicles[currentGreen][0])+len(vehicles[currentGreen][1])+len(vehicles[currentGreen][2])
+    # noOfVehicles = len(vehicles[directionNumbers[nextGreen]][1])+len(vehicles[directionNumbers[nextGreen]][2])-vehicles[directionNumbers[nextGreen]]['crossed']
+    # print("no. of vehicles = ",noOfVehicles)
+    noOfCars, noOfBuses, noOfTrucks, noOfBikes = 0,0,0,0
+    for j in range(len(vehicles[directionNumbers[nextGreen]][0])):
+        vehicle = vehicles[directionNumbers[nextGreen]][0][j]
+        if(vehicle.crossed==0):
+            vclass = vehicle.vehicleClass
+            # print(vclass)
+            noOfBikes += 1
+    for i in range(1,3):
+        for j in range(len(vehicles[directionNumbers[nextGreen]][i])):
+            vehicle = vehicles[directionNumbers[nextGreen]][i][j]
+            if(vehicle.crossed==0):
+                vclass = vehicle.vehicleClass
+                # print(vclass)
+                if(vclass=='car'):
+                    noOfCars += 1
+                elif(vclass=='bus'):
+                    noOfBuses += 1
+                elif(vclass=='truck'):
+                    noOfTrucks += 1
+    # print(noOfCars)
+    greenTime = math.ceil(((noOfCars*carTime) + (noOfBuses*busTime) + (noOfTrucks*truckTime)+ (noOfBikes*bikeTime))/(noOfLanes+1))
+    # greenTime = math.ceil((noOfVehicles)/noOfLanes) 
+    print('Green Time: ',greenTime)
+    if(greenTime<defaultMinimum):
+        greenTime = defaultMinimum
+    elif(greenTime>defaultMaximum):
+        greenTime = defaultMaximum
+    # greenTime = random.randint(15,50)
+    signals[(currentGreen+1)%(noOfSignals)].green = greenTime
+   
+def repeat():
+    global currentGreen, currentYellow, nextGreen
+    while(signals[currentGreen].green>0):   # while the timer of current green signal is not zero
+        printStatus()
+        updateValues()
+        if(signals[(currentGreen+1)%(noOfSignals)].red==detectionTime):    # set time of next green signal 
+            thread = threading.Thread(name="detection",target=setTime, args=())
+            thread.daemon = True
+            thread.start()
+            # setTime()
+        time.sleep(1)
+    currentYellow = 1   # set yellow signal on
+    vehicleCountTexts[currentGreen] = "0"
+    # reset stop coordinates of lanes and vehicles 
+    for i in range(0,3):
+        stops[directionNumbers[currentGreen]][i] = defaultStop[directionNumbers[currentGreen]]
+        for vehicle in vehicles[directionNumbers[currentGreen]][i]:
+            vehicle.stop = defaultStop[directionNumbers[currentGreen]]
+    while(signals[currentGreen].yellow>0):  # while the timer of current yellow signal is not zero
+        printStatus()
+        updateValues()
+        time.sleep(1)
+    currentYellow = 0   # set yellow signal off
+    
+    # reset all signal times of current signal to default times
+    signals[currentGreen].green = defaultGreen
+    signals[currentGreen].yellow = defaultYellow
+    signals[currentGreen].red = defaultRed
+       
+    currentGreen = nextGreen # set next signal as green signal
+    nextGreen = (currentGreen+1)%noOfSignals    # set next green signal
+    signals[nextGreen].red = signals[currentGreen].yellow+signals[currentGreen].green    # set the red time of next to next signal as (yellow time + green time) of next signal
+    repeat()     
+
+# Print the signal timers on cmd
+def printStatus():                                                                                           
+	for i in range(0, noOfSignals):
+		if(i==currentGreen):
+			if(currentYellow==0):
+				print(" GREEN TS",i+1,"-> r:",signals[i].red," y:",signals[i].yellow," g:",signals[i].green)
+			else:
+				print("YELLOW TS",i+1,"-> r:",signals[i].red," y:",signals[i].yellow," g:",signals[i].green)
+		else:
+			print("   RED TS",i+1,"-> r:",signals[i].red," y:",signals[i].yellow," g:",signals[i].green)
+	print()
+
+# Update values of the signal timers after every second
+def updateValues():
+    for i in range(0, noOfSignals):
+        if(i==currentGreen):
+            if(currentYellow==0):
+                signals[i].green-=1
+                signals[i].totalGreenTime+=1
+            else:
+                signals[i].yellow-=1
+        else:
+            signals[i].red-=1
+
+# Generating vehicles in the simulation
+def generateVehicles():
+    while True:
+        vehicle_type = random.randint(0, 3)
+        if vehicle_type == 3:
+            lane_number = 0
+        else:
+            lane_number = random.randint(0, 1) + 1
+        will_turn = 0
+        if lane_number == 2:
+            temp = random.randint(0, 4)
+            if temp <= 2:
+                will_turn = 1
+            elif temp > 2:
+                will_turn = 0
+        temp = random.randint(0, 999)
+        direction_number = 0
+        a = [400, 800, 900, 1000]
+        if temp < a[0]:
+            direction_number = 0
+        elif temp < a[1]:
+            direction_number = 1
+        elif temp < a[2]:
+            direction_number = 2
+        elif temp < a[3]:
+            direction_number = 3
+        Vehicle(lane_number, vehicleTypes[vehicle_type], direction_number, directionNumbers[direction_number], will_turn)
+        time.sleep(0.75)
+
+def simulationTime():
+    global timeElapsed, simTime
+    while(True):
+        timeElapsed += 1
+        time.sleep(1)
+        if(timeElapsed==simTime):
+            totalVehicles = 0
+            print('Lane-wise Vehicle Counts')
+            for i in range(noOfSignals):
+                print('Lane',i+1,':',vehicles[directionNumbers[i]]['crossed'])
+                totalVehicles += vehicles[directionNumbers[i]]['crossed']
+            print('Total vehicles passed: ',totalVehicles)
+            print('Total time passed: ',timeElapsed)
+            print('No. of vehicles passed per unit time: ',(float(totalVehicles)/float(timeElapsed)))
+            os._exit(1)
+    
+
+class Main:
+    thread4 = threading.Thread(name="simulationTime",target=simulationTime, args=()) 
+    thread4.daemon = True
+    thread4.start()
+
+    thread2 = threading.Thread(name="initialization",target=initialize, args=())    # initialization
+    thread2.daemon = True
+    thread2.start()
+
+    # Colours 
+    black = (0, 0, 0)
+    white = (255, 255, 255)
+
+    # Screensize 
+    screenWidth = 1400
+    screenHeight = 800
+    screenSize = (screenWidth, screenHeight)
+
+    # Setting background image i.e. image of intersection
+    background = pygame.image.load('images/mod_int.png')
+
+    screen = pygame.display.set_mode(screenSize)
+    pygame.display.set_caption("SIMULATION")
+
+    # Loading signal images and font
+    redSignal = pygame.image.load('images/signals/red.png')
+    yellowSignal = pygame.image.load('images/signals/yellow.png')
+    greenSignal = pygame.image.load('images/signals/green.png')
+    font = pygame.font.Font(None, 30)
+
+    thread3 = threading.Thread(name="generateVehicles",target=generateVehicles, args=())    # Generating vehicles
+    thread3.daemon = True
+    thread3.start()
+
+    while True:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                sys.exit()
+
+        screen.blit(background,(0,0))   # display background in simulation
+        for i in range(0,noOfSignals):  # display signal and set timer according to current status: green, yello, or red
+            if(i==currentGreen):
+                if(currentYellow==1):
+                    if(signals[i].yellow==0):
+                        signals[i].signalText = "STOP"
+                    else:
+                        signals[i].signalText = signals[i].yellow
+                    screen.blit(yellowSignal, signalCoods[i])
+                else:
+                    if(signals[i].green==0):
+                        signals[i].signalText = "SLOW"
+                    else:
+                        signals[i].signalText = signals[i].green
+                    screen.blit(greenSignal, signalCoods[i])
+            else:
+                if(signals[i].red<=10):
+                    if(signals[i].red==0):
+                        signals[i].signalText = "GO"
+                    else:
+                        signals[i].signalText = signals[i].red
+                else:
+                    signals[i].signalText = "---"
+                screen.blit(redSignal, signalCoods[i])
+        signalTexts = ["","","",""]
+
+        # display signal timer and vehicle count
+        for i in range(0,noOfSignals):  
+            signalTexts[i] = font.render(str(signals[i].signalText), True, white, black)
+            screen.blit(signalTexts[i],signalTimerCoods[i]) 
+            displayText = vehicles[directionNumbers[i]]['crossed']
+            vehicleCountTexts[i] = font.render(str(displayText), True, black, white)
+            screen.blit(vehicleCountTexts[i],vehicleCountCoods[i])
+
+        timeElapsedText = font.render(("Time Elapsed: "+str(timeElapsed)), True, black, white)
+        screen.blit(timeElapsedText,(1100,50))
+
+        # display the vehicles
+        for vehicle in simulation:  
+            screen.blit(vehicle.currentImage, [vehicle.x, vehicle.y])
+            # vehicle.render(screen)
+            vehicle.move()
+        pygame.display.update()
+
+Main()
+
+  
+

traffic-light-management-using-AI-main/traffic-light-management-using-AI-main/tracker.py

@@ -0,0 +1,56 @@
+# TechVidvan Vehicle-Tracker
+
+import math
+
+class EuclideanDistTracker:
+    def __init__(self):
+        # Store the center positions of the objects
+        self.center_points = {}
+        # Keep the count of the IDs
+        # each time a new object id detected, the count will increase by one
+        self.id_count = 0
+
+
+    def update(self, objects_rect):
+        # Objects boxes and ids
+        objects_bbs_ids = []
+
+        # Get center point of new object
+        for rect in objects_rect:
+            x, y, w, h, index = rect
+            cx = (x + x + w) // 2
+            cy = (y + y + h) // 2
+
+            # Find out if that object was detected already
+            same_object_detected = False
+            for id, pt in self.center_points.items():
+                dist = math.hypot(cx - pt[0], cy - pt[1])
+
+                if dist < 25:
+                    self.center_points[id] = (cx, cy)
+                    # print(self.center_points)
+                    objects_bbs_ids.append([x, y, w, h, id, index])
+                    same_object_detected = True
+                    break
+
+            # New object is detected we assign the ID to that object
+            if same_object_detected is False:
+                self.center_points[self.id_count] = (cx, cy)
+                objects_bbs_ids.append([x, y, w, h, self.id_count, index])
+                self.id_count += 1
+
+        # Clean the dictionary by center points to remove IDS not used anymore
+        new_center_points = {}
+        for obj_bb_id in objects_bbs_ids:
+            _, _, _, _, object_id, index = obj_bb_id
+            center = self.center_points[object_id]
+            new_center_points[object_id] = center
+
+        # Update dictionary with IDs not used removed
+        self.center_points = new_center_points.copy()
+        return objects_bbs_ids
+
+
+
+def ad(a, b):
+    return a+b

traffic-light-management-using-AI-main/traffic-light-management-using-AI-main/vehicle_count.py

@@ -0,0 +1,209 @@
+# TechVidvan Vehicle counting and Classification
+
+# Import necessary packages
+
+import cv2
+import csv
+import collections
+import numpy as np
+from tracker import *
+import os
+
+# Initialize Tracker
+tracker = EuclideanDistTracker()
+
+# Initialize the videocapture object
+cap = cv2.VideoCapture('video.mp4')
+input_size = 320
+
+# Detection confidence threshold
+confThreshold =0.2
+nmsThreshold= 0.2
+
+font_color = (0, 0, 255)
+font_size = 0.5
+font_thickness = 2
+
+# Middle cross line position
+middle_line_position = 225   
+up_line_position = middle_line_position - 15
+down_line_position = middle_line_position + 15
+
+
+# Store Coco Names in a list
+classesFile = "coco.names"
+classNames = open(classesFile).read().strip().split('\n')
+print(classNames)
+print(len(classNames))
+
+# class index for our required detection classes
+required_class_index = [2, 3, 5, 7]
+
+detected_classNames = []
+
+## Model Files
+modelConfiguration = 'yolov3-320.cfg'
+modelWeigheights = 'yolov3-320.weights'
+
+# configure the network model
+net = cv2.dnn.readNetFromDarknet(modelConfiguration, modelWeigheights)
+
+# Configure the network backend
+
+# Configure the network backend
+net.setPreferableBackend(cv2.dnn.DNN_BACKEND_DEFAULT)
+net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)
+
+# Define random colour for each class
+np.random.seed(42)
+colors = np.random.randint(0, 255, size=(len(classNames), 3), dtype='uint8')
+
+
+# Function for finding the center of a rectangle
+def find_center(x, y, w, h):
+    x1=int(w/2)
+    y1=int(h/2)
+    cx = x+x1
+    cy=y+y1
+    return cx, cy
+    
+# List for store vehicle count information
+temp_up_list = []
+temp_down_list = []
+up_list = [0, 0, 0, 0]
+down_list = [0, 0, 0, 0]
+
+# Function for count vehicle
+def count_vehicle(box_id, img):
+
+    x, y, w, h, id, index = box_id
+
+    # Find the center of the rectangle for detection
+    center = find_center(x, y, w, h)
+    ix, iy = center
+    
+    # Find the current position of the vehicle
+    if (iy > up_line_position) and (iy < middle_line_position):
+
+        if id not in temp_up_list:
+            temp_up_list.append(id)
+
+    elif iy < down_line_position and iy > middle_line_position:
+        if id not in temp_down_list:
+            temp_down_list.append(id)
+            
+    elif iy < up_line_position:
+        if id in temp_down_list:
+            temp_down_list.remove(id)
+            up_list[index] = up_list[index]+1
+
+    elif iy > down_line_position:
+        if id in temp_up_list:
+            temp_up_list.remove(id)
+            down_list[index] = down_list[index] + 1
+
+    # Draw circle in the middle of the rectangle
+    cv2.circle(img, center, 2, (0, 0, 255), -1)  # end here
+    # print(up_list, down_list)
+
+# Function for finding the detected objects from the network output
+def postProcess(outputs,img):
+    global detected_classNames 
+    height, width = img.shape[:2]
+    boxes = []
+    classIds = []
+    confidence_scores = []
+    detection = []
+    for output in outputs:
+        for det in output:
+            scores = det[5:]
+            classId = np.argmax(scores)
+            confidence = scores[classId]
+            if classId in required_class_index:
+                if confidence > confThreshold:
+                    # print(classId)
+                    w,h = int(det[2]*width) , int(det[3]*height)
+                    x,y = int((det[0]*width)-w/2) , int((det[1]*height)-h/2)
+                    boxes.append([x,y,w,h])
+                    classIds.append(classId)
+                    confidence_scores.append(float(confidence))
+
+    # Apply Non-Max Suppression
+    indices = cv2.dnn.NMSBoxes(boxes, confidence_scores, confThreshold, nmsThreshold)
+    # print(classIds)
+    for i in indices.flatten():
+        x, y, w, h = boxes[i][0], boxes[i][1], boxes[i][2], boxes[i][3]
+        # print(x,y,w,h)
+
+        color = [int(c) for c in colors[classIds[i]]]
+        name = classNames[classIds[i]]
+        detected_classNames.append(name)
+        # Draw classname and confidence score 
+        cv2.putText(img,f'{name.upper()} {int(confidence_scores[i]*100)}%',
+                  (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
+
+        # Draw bounding rectangle
+        cv2.rectangle(img, (x, y), (x + w, y + h), color, 1)
+        detection.append([x, y, w, h, required_class_index.index(classIds[i])])
+
+    # Update the tracker for each object
+    boxes_ids = tracker.update(detection)
+    for box_id in boxes_ids:
+        count_vehicle(box_id, img)
+
+
+def realTime():
+    while True:
+        success, img = cap.read()
+        img = cv2.resize(img,(0,0),None,0.5,0.5)
+        ih, iw, channels = img.shape
+        
+        blob = cv2.dnn.blobFromImage(img, 1 / 255, (input_size, input_size), [0, 0, 0], 1, crop=False)
+
+        # Set the input of the network
+        net.setInput(blob)
+        layersNames = net.getLayerNames()
+        outputNames = [(layersNames[i - 1]) for i in net.getUnconnectedOutLayers()]
+        # Feed data to the network
+        outputs = net.forward(outputNames)
+    
+        # Find the objects from the network output
+        postProcess(outputs,img)
+
+        # Draw the crossing lines
+
+        cv2.line(img, (0, middle_line_position), (iw, middle_line_position), (255, 0, 255), 2)
+        cv2.line(img, (0, up_line_position), (iw, up_line_position), (0, 0, 255), 2)
+        cv2.line(img, (0, down_line_position), (iw, down_line_position), (0, 0, 255), 2)
+
+        # Draw counting texts in the frame
+        cv2.putText(img, "Up", (110, 20), cv2.FONT_HERSHEY_SIMPLEX, font_size, font_color, font_thickness)
+        cv2.putText(img, "Down", (160, 20), cv2.FONT_HERSHEY_SIMPLEX, font_size, font_color, font_thickness)
+        cv2.putText(img, "Car:        "+str(up_list[0])+"     "+ str(down_list[0]), (20, 40), cv2.FONT_HERSHEY_SIMPLEX, font_size, font_color, font_thickness)
+        cv2.putText(img, "Motorbike:  "+str(up_list[1])+"     "+ str(down_list[1]), (20, 60), cv2.FONT_HERSHEY_SIMPLEX, font_size, font_color, font_thickness)
+        cv2.putText(img, "Bus:        "+str(up_list[2])+"     "+ str(down_list[2]), (20, 80), cv2.FONT_HERSHEY_SIMPLEX, font_size, font_color, font_thickness)
+        cv2.putText(img, "Truck:      "+str(up_list[3])+"     "+ str(down_list[3]), (20, 100), cv2.FONT_HERSHEY_SIMPLEX, font_size, font_color, font_thickness)
+
+        # Show the frames
+        cv2.imshow('Output', img)
+
+        if cv2.waitKey(1) == ord('q'):
+            break
+
+    # Write the vehicle counting information in a file and save it
+
+    with open("data.csv", 'w') as f1:
+        cwriter = csv.writer(f1)
+        cwriter.writerow(['Direction', 'car', 'motorbike', 'bus', 'truck'])
+        up_list.insert(0, "Up")
+        down_list.insert(0, "Down")
+        cwriter.writerow(up_list)
+        cwriter.writerow(down_list)
+    f1.close()
+    # print("Data saved at 'data.csv'")
+    # Finally realese the capture object and destroy all active windows
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == '__main__':
+    realTime()

traffic-light-management-using-AI-main/traffic-light-management-using-AI-main/yolov3-320.cfg

@@ -0,0 +1,788 @@
+[net]
+# Testing
+# batch=1
+# subdivisions=1
+# Training
+batch=64
+subdivisions=16
+width=608
+height=608
+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

yolov3-320.weights

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