# -*- coding: utf-8 -*-
"""
Created on 2020/5/26 22:21
@author: Johnson
Email:[email protected]
"""
import random
import os
import subprocess
import sys
def split_data_set(image_dir):
f_val = open("test.txt","w")
f_train = open("train.txt","w")
path,dirs,files = next(os.walk(image_dir))
data_size = len(files)
ind = 0
data_test_size = int(0.1*data_size)
test_array = random.sample(range(data_size),k=data_test_size)
for f in os.listdir(image_dir):
if (f.split(".")[1]=="jpg"):
ind+=1
if ind in test_array:
f_val.write(image_dir+"/"+f+"\n")
else:
f_train.write(image_dir+"/"+f+"\n")
split_data_set(sys.argv[1])
plotTrainloss
# -*- coding: utf-8 -*-
"""
Created on 2020/5/26 22:28
@author: Johnson
Email:[email protected]
"""
import sys
import matplotlib.pyplot as plt
lines = []
for line in open(sys.argv[1]):
if "avg" in line:
lines.append(line)
iterations = []
avg_loss = []
print('Retrieving data and plotting training loss graph...')
for i in range(len(lines)):
lineParts = lines[i].split(',')
iterations.append(int(lineParts[0].split(':')[0]))
avg_loss.append(float(lineParts[1].split()[0]))
fig = plt.figure()
for i in range(0, len(lines)):
plt.plot(iterations[i:i+2], avg_loss[i:i+2], 'r.-')
plt.xlabel('Batch Number')
plt.ylabel('Avg Loss')
fig.savefig('training_loss_plot.png', dpi=1000)
print('Done! Plot saved as training_loss_plot.png')
# -*- coding: utf-8 -*-
"""
Created on 2020/5/26 22:29
@author: Johnson
Email:[email protected]
"""
# Usage example: python3 object_detection_yolo.py --video=run.mp4
# python3 object_detection_yolo.py --image=bird.jpg
import cv2 as cv
import argparse
import sys
import numpy as np
import os.path
#初始化參數
confThreshold = 0.5 #置信度閾值
nmsThreshold = 0.4 # nms閾值
inpWidth = 416 #608
inpHight = 416 #608
parser = argparse.ArgumentParser()
parser.add_argument("--image",help="Path to image file")
parser.add_argument("--video",help="Path to video file")
#分類名稱
classesFile = "classes.names"
classes = None
with open(classesFile,"rt") as f:
classes = f.read().rstrip("\n").split("\n")
# Give the configuration and weight files for the model and load the network using them.
modelConfiguration = "darknet-yolov3.cfg";
modelWeights = "darknet-yolov3_final.weights";
#
net = cv.dnn.readNetFromDarknet(modelConfiguration,modelWeights)
net.setPreferableBackend(cv.dnn.DNN_BACKEND_OPENCV)
net.setPreferableTarget(cv.dnn.DNN_TARGET_CPU)
# Get the names of the output layers
def getOutputsNames(net):
# Get the names of all the layers in the network
layersNames = net.getLayerNames()
# Get the names of the output layers, i.e. the layers with unconnected outputs
return [layersNames[i[0] - 1] for i in net.getUnconnectedOutLayers()]
#darw the predicted bounding box
def drawPred(classId,conf,letf,top,right,bottom):
#draw the bounding box
# cv.rectangle(frame,(left,top),(right,bottom),(255,178,50),3)
cv.rectangle(frame, (left, top), (right, bottom), (0, 255, 0), 3)
label = "%.2f"%conf
#get the label for the class name and its confidence
if classes:
assert (classId<len(classes))
# Display the label at the top of the bounding box
labelSize, baseLine = cv.getTextSize(label, cv.FONT_HERSHEY_SIMPLEX, 0.5, 1)
top = max(top, labelSize[1])
cv.rectangle(frame, (left, top - round(1.5 * labelSize[1])), (left + round(1.5 * labelSize[0]), top + baseLine),
(0, 0, 255), cv.FILLED)
# cv.rectangle(frame, (left, top - round(1.5*labelSize[1])), (left + round(1.5*labelSize[0]), top + baseLine), (255, 255, 255), cv.FILLED)
cv.putText(frame, label, (left, top), cv.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 0), 2)
# Remove the bounding boxes with low confidence using non-maxima suppression
def postprocess(frame, outs):
frameHeight = frame.shape[0]
frameWidth = frame.shape[1]
classIds = []
confidences = []
boxes = []
# Scan through all the bounding boxes output from the network and keep only the
# ones with high confidence scores. Assign the box's class label as the class with the highest score.
classIds = []
confidences = []
boxes = []
for out in outs:
print("out.shape : ", out.shape)
for detection in out:
#if detection[4]>0.001:
scores = detection[5:]
classId = np.argmax(scores)
#if scores[classId]>confThreshold:
confidence = scores[classId]
if detection[4]>confThreshold:
print(detection[4], " - ", scores[classId], " - th : ", confThreshold)
print(detection)
if confidence > confThreshold:
center_x = int(detection[0] * frameWidth)
center_y = int(detection[1] * frameHeight)
width = int(detection[2] * frameWidth)
height = int(detection[3] * frameHeight)
left = int(center_x - width / 2)
top = int(center_y - height / 2)
classIds.append(classId)
confidences.append(float(confidence))
boxes.append([left, top, width, height])
# Perform non maximum suppression to eliminate redundant overlapping boxes with
# lower confidences.
indices = cv.dnn.NMSBoxes(boxes, confidences, confThreshold, nmsThreshold)
for i in indices:
i = i[0]
box = boxes[i]
left = box[0]
top = box[1]
width = box[2]
height = box[3]
drawPred(classIds[i], confidences[i], left, top, left + width, top + height)
# Process inputs
winName = 'Deep learning object detection in OpenCV'
cv.namedWindow(winName, cv.WINDOW_NORMAL)
outputFile = "yolo_out_py.avi"
if (args.image):
# Open the image file
if not os.path.isfile(args.image):
print("Input image file ", args.image, " doesn't exist")
sys.exit(1)
cap = cv.VideoCapture(args.image)
outputFile = args.image[:-4] + '_yolo_out_py.jpg'
elif (args.video):
# Open the video file
if not os.path.isfile(args.video):
print("Input video file ", args.video, " doesn't exist")
sys.exit(1)
cap = cv.VideoCapture(args.video)
outputFile = args.video[:-4] + '_yolo_out_py.avi'
else:
# Webcam input
cap = cv.VideoCapture(0)
# Get the video writer initialized to save the output video
if (not args.image):
vid_writer = cv.VideoWriter(outputFile, cv.VideoWriter_fourcc('M', 'J', 'P', 'G'), 30,
(round(cap.get(cv.CAP_PROP_FRAME_WIDTH)), round(cap.get(cv.CAP_PROP_FRAME_HEIGHT))))
while cv.waitKey(1) < 0:
# get frame from the video
hasFrame, frame = cap.read()
# Stop the program if reached end of video
if not hasFrame:
print("Done processing !!!")
print("Output file is stored as ", outputFile)
cv.waitKey(3000)
break
# Create a 4D blob from a frame.
blob = cv.dnn.blobFromImage(frame, 1 / 255, (inpWidth, inpHeight), [0, 0, 0], 1, crop=False)
# Sets the input to the network
net.setInput(blob)
# Runs the forward pass to get output of the output layers
outs = net.forward(getOutputsNames(net))
# Remove the bounding boxes with low confidence
postprocess(frame, outs)
# Put efficiency information. The function getPerfProfile returns the overall time for inference(t) and the timings for each of the layers(in layersTimes)
t, _ = net.getPerfProfile()
label = 'Inference time: %.2f ms' % (t * 1000.0 / cv.getTickFrequency())
# cv.putText(frame, label, (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255))
# Write the frame with the detection boxes
if (args.image):
cv.imwrite(outputFile, frame.astype(np.uint8));
else:
vid_writer.write(frame.astype(np.uint8))
cv.imshow(winName, frame)
