import argparse
import os
import matplotlib.pyplot as plt
from matplotlib.pyplot import imshow
import scipy.io
import scipy.misc
import numpy as np
import pandas as pd
import PIL
import tensorflow as tf
from keras import backend as K
from keras.layers import Input, Lambda, Conv2D
from keras.models import load_model, Model
from yolo_utils import read_classes, read_anchors, generate_colors, preprocess_image, draw_boxes, scale_boxes
from yad2k.models.keras_yolo import yolo_head, yolo_boxes_to_corners, preprocess_true_boxes, yolo_loss, yolo_body
sess = K.get_session()
class_names = read_classes("model_data/coco_classes.txt")
anchors = read_anchors("model_data/yolo_anchors.txt")
image_shape = (720., 1280.)
yolo_model = load_model("model_data/yolo.h5")
# tf.random_normal([19, 19, 5, 2], mean=1, stddev=4, seed = 1),
# tf.random_normal([19, 19, 5, 80], mean=1, stddev=4, seed = 1))
# scores, boxes, classes = yolo_eval(yolo_outputs)
# print("scores[2] = " + str(scores[2].eval()))
# print("boxes[2] = " + str(boxes[2].eval()))
# print("classes[2] = " + str(classes[2].eval()))
# print("scores.shape = " + str(scores.eval().shape))
# print("boxes.shape = " + str(boxes.eval().shape))
# print("classes.shape = " + str(classes.eval().shape))
# Test YOLO pretrained model on images
# Create a session to start your graph
sess = K.get_session()
# loading class_name,anchors
class_names = read_classes('model_data/coco_classes.txt')
anchors = read_anchors('model_data/yolo_anchors.txt')
image_shape = (720., 1280.)
# Loading a pre_trained model which's shape of output is (m,19,19,425)
yolo_model = load_model('model_data/yolo.h5')
#Show detail of the model
yolo_model.summary()
# Convert output of the model to usable bounding box tensors (m,19,19,5,85)-->(m,19,19,5,1)、(m,19,19,5,4)、(m,19,19,5,80)
yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))
# Filter boxes
scores, boxes, classes = yolo_eval(yolo_outputs, image_shape)
import scipy.io
import scipy.misc
import numpy as np
import pandas as pd
import PIL
import tensorflow as tf
from keras import backend as K
from keras.layers import Input, Lambda, Conv2D
from keras.models import load_model, Model
from yolo_utils import read_classes, read_anchors, generate_colors, preprocess_image, draw_boxes, scale_boxes
from yad2k.models.keras_yolo import yolo_head, yolo_boxes_to_corners, preprocess_true_boxes, yolo_loss, yolo_body
import keras
import sys
import os
class_names = read_classes("model_data/coco_classes.txt")
anchors = read_anchors("model_data/yolo_anchors.txt")
image_shape = (720., 1280.)
yolo_model = load_model("yolo.h5")
yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))
def yolo_filter_boxes(box_confidence, boxes, box_class_probs, threshold=.6):
"""Filters YOLO boxes by thresholding on object and class confidence."""
box_scores = box_confidence * box_class_probs
box_classes = keras.backend.argmax(box_scores, axis=-1)
box_class_scores = keras.backend.max(box_scores, axis=-1)
print("在" + str(image_file) + "中找到了" + str(len(out_boxes)) + "个锚框。")
#指定要绘制的边界框的颜色
colors = yolo_utils.generate_colors(class_names)
#在图中绘制边界框
yolo_utils.draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
#保存已经绘制了边界框的图
image.save(os.path.join("out", image_file), quality=100)
#打印出已经绘制了边界框的图
if is_plot:
output_image = scipy.misc.imread(os.path.join("out", image_file))
plt.imshow(output_image)
return out_scores, out_boxes, out_classes
if __name__ == '__main__':
with tf.Session() as sess:
class_names = yolo_utils.read_classes(r"E:\深度学习\第四课第三周编程作业\Car detection for Autonomous Driving\model_data/coco_classes.txt")
anchors = yolo_utils.read_anchors(r"E:\深度学习\第四课第三周编程作业\Car detection for Autonomous Driving\model_data/yolo_anchors.txt")
image_shape = (720., 1280.)
yolo_model = load_model(r"E:\深度学习\第四课第三周编程作业\Car detection for Autonomous Driving\model_data/yolo.h5")
yolo_model.summary()
yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))
scores, boxes, classes = yolo_eval(yolo_outputs, image_shape)
out_scores, out_boxes, out_classes = predict(sess, r"0083.jpg")
# Scale boxes back to original image shape.
boxes = scale_boxes(boxes, image_shape)
# Use function Non-max suppression with a threshold of iou_threshold
scores, boxes, classes = yolo_non_max_suppression(scores, boxes, classes, max_boxes = 10, iou_threshold = 0.5)
return scores, boxes, classes
#creating a session to start our graph
sess = K.get_session()
#The car detection dataset has 720x1280 images, which we've pre-processed into 608x608 images.
class_names = read_classes("coco_classes.txt")
anchors = read_anchors("yolo_anchors.txt")
image_shape = (720., 1280.)
#Loading a pretrained model- yolo.h5
yolo_model = load_model("yolo.h5")
#summary of the layers our model yolo.h5 contains.
yolo_model.summary()
#Converting output of the model to usable bounding box tensors
yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))
#Filtering boxes
scores, boxes, classes = yolo_eval(yolo_outputs, image_shape)
#pridect
res = pridect(images, dec_image, yolo_model)
#frame = cv.resize(frame, (96),(96))
display = np.array(res)
cv.imshow("Yolo", display)
# cv.imshow("Yolo", frame)
out.write(display)
# 等待30ms显示图像，若过程中按“Esc”退出
c = cv.waitKey(30) & 0xff
if c == 27:
capture.release()
break
# yolo = YOLO()
class_names = yolo_utils.read_classes(current_path +
"/model_data/voc_classes.txt")
anchors = yolo_utils.read_anchors(current_path +
"/model_data/yolo_anchors.txt")
num_classes = len(class_names)
num_anchors = len(anchors)
input_shape = (416, 416)
image_input = Input(shape=(None, None, 3))
h, w = input_shape
model = yolo_body(image_input, num_anchors // 3, num_classes)
model.load_weights("logs/ep055-loss18.931-val_loss20.760.h5",
by_name=True,
skip_mismatch=True)
model.summary()
model.compile(optimizer='Adam',
loss={
'yolo_loss': lambda y_true, y_pred: y_pred
# In this part, you are going to use a **pretrained model** and test it on the car detection dataset. As usual, you start by **creating a session to start your graph**. Run the following cell.
# In[10]:
sess = K.get_session() #creating a session to start your graph
# ### 3.1 - Defining classes, anchors and image shape.
# Recall that we are trying to detect **80 classes**, and are using **5 anchor boxes**. We have gathered the information about the 80 classes and 5 boxes in two files "coco_classes.txt" and "yolo_anchors.txt". Let's load these quantities into the model by running the next cell.
#
# The car detection dataset has 720x1280 images, which we've pre-processed into 608x608 images.
# In[11]:
class_names = read_classes("model_data/coco_classes.txt")#person、bicycle、car、motorbike、aeroplane...
anchors = read_anchors("model_data/yolo_anchors.txt") #值为0.57273, 0.677385, 1.87446, 2.06253, 3.33843, 5.47434, 7.88282, 3.52778, 9.77052, 9.16828
image_shape = (720., 1280.)
# ### 3.2 - Loading a pretrained model 直接导入预训练好的模型，不需要再训练CNN了
#
# Training a YOLO model **takes a very long time** and requires a fairly large dataset of **labelled bounding boxes for a large range of target classes.** You are going to load an existing pretrained Keras YOLO model stored in "yolo.h5". (These weights come from the **official YOLO website**, and were converted using a function written by Allan Zelener. References are at the end of this notebook. Technically, these are the parameters from the **"YOLOv2" model,** but we will more simply refer to it as "YOLO" in this notebook.) Run the cell below to load the model from this file.
# In[12]:
yolo_model = load_model("model_data/yolo.h5")
# This loads the weights of a trained YOLO model. Here's a summary of the layers your model contains.
import argparse
import numpy as np
import tensorflow as tf
import time
import os
import glob
os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"
# might need to set random seed the same in debug
# np.random.seed(101)
# Get Data #############################################################################################################
PATH = path
DATA_PATH = data_path
classes_paths = PATH + '/model/kitti_classes.txt'
classes_data = read_classes(classes_paths)
anchors_paths = PATH + '/model/kitti_anchors.txt'
anchors = read_anchors(anchors_paths)
print ("Number of classes: ", len(classes_data))
annotation_path_train = PATH + '/model/kitti_train.txt'
annotation_path_valid = PATH + '/model/kitti_train.txt'
annotation_path_test = PATH + '/model/kitti_train.txt'
label_train = []
label_valid = []
with open(annotation_path_train) as f:
label_train = f.readlines()
with open(annotation_path_valid) as f:
label_valid = f.readlines()
import pandas as pd
import PIL
import tensorflow as tf
from keras import backend as K
from keras.layers import Input, Lambda, Conv2D
from keras.models import load_model, Model
from yolo_utils import read_classes, read_anchors, generate_colors, preprocess_image, draw_boxes, scale_boxes
from yad2k.models.keras_yolo import yolo_head, yolo_boxes_to_corners, preprocess_true_boxes, yolo_loss, yolo_body
import yolo_filter_boxes
import iou
import yolo_non_max_suppression
import yolo_eval
sess = K.get_session()
yolo_model = load_model("C:/Users/Vikarn Bhakri/Downloads/yolo.h5")
class_names = read_classes(
"C:/Users/Vikarn Bhakri/Desktop/model_data/coco_classes.txt")
anchors = read_anchors(
"C:/Users/Vikarn Bhakri/Desktop/model_data/yolo_anchors.txt")
image_shape = (720., 1280.)
yolo_model.summary()
yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))
scores, boxes, classes = yolo_eval(yolo_outputs, image_shape)
image, image_data = preprocess_image("C:/Users/Vikarn Bhakri/Desktop/images/" +
"test.jpg",
model_image_size=(608, 608))
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes],
feed_dict={
yolo_model.input: image_data,
K.learning_phase(): 0
})
def getFrame(sec):
vidcap.set(cv2.CAP_PROP_POS_MSEC, sec * 1000)
hasFrames, image = vidcap.read()
if hasFrames:
path = "/Users/prachis/pet_projects/YOLOv2_keras/images/"
cv2.imwrite(os.path.join(path, "image" + str(count) + ".jpg"), image)
# cv2.imwrite("image"+str(count)+".jpg", image) # save frame as JPG file
input_image_name = "image" + str(count) + ".jpg"
# Obtaining the dimensions of the input image
input_image = Image.open(
"/Users/prachis/pet_projects/YOLOv2_keras/images/" +
input_image_name)
width, height = input_image.size
width = np.array(width, dtype=float)
height = np.array(height, dtype=float)
# Assign the shape of the input image to image_shapr variable
image_shape = (height, width)
# Loading the classes and the anchor boxes that are provided in the madel_data folder
class_names = read_classes("model_data/coco_classes.txt")
anchors = read_anchors("model_data/yolo_anchors.txt")
# Load the pretrained model. Please refer the README file to get info on how to obtain the yolo.h5 file
yolo_model = load_model("model_data/yolo.h5")
# Print the summery of the model
# yolo_model.summary()
# Convert final layer features to bounding box parameters
yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))
# Now yolo_eval function selects the best boxes using filtering and non-max suppression techniques.
# If you want to dive in more to see how this works, refer keras_yolo.py file in yad2k/models
boxes, scores, classes = yolo_eval(yolo_outputs, image_shape)
# Initiate a session
sess = K.get_session()
# Preprocess the input image before feeding into the convolutional network
image, image_data = preprocess_image(
"/Users/prachis/pet_projects/YOLOv2_keras/images/" +
input_image_name,
model_image_size=(608, 608))
# Run the session
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes],
feed_dict={
yolo_model.input:
image_data,
K.learning_phase(): 0
})
# Print the results
print('Found {} boxes for {}'.format(len(out_boxes), input_image_name))
# Produce the colors for the bounding boxs
colors = generate_colors(class_names)
# Draw the bounding boxes
draw_boxes(image, out_scores, out_boxes, out_classes, class_names,
colors)
# Apply the predicted bounding boxes to the image and save it
image.save(os.path.join(
"/Users/prachis/pet_projects/YOLOv2_keras/out/", input_image_name),
quality=90)
output_image = imageio.imread(
os.path.join("/Users/prachis/pet_projects/YOLOv2_keras/out/",
input_image_name))
return hasFrames
return scores, boxes, classes
scores, boxes, classes = yolo_eval(yolo_outputs)
with tf.Session() as test_b:
print("scores[2] = " + str(scores[2].eval()))
print("boxes[2] = " + str(boxes[2].eval()))
print("classes[2] = " + str(classes[2].eval()))
################################################################
sess = K.get_session()
class_names = read_classes("sambid/model_data/coco_classes.txt")
anchors = read_anchors("sambid/model_data/yolo_anchors.txt")
yolo_model = load_model("sambid/model_data/yolo.h5")
yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))
def predict(sess, image_file):
image, image_data = preprocess_image("images/" + image_file, model_image_size = (608, 608))
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes], feed_dict={yolo_model.input: image_data, K.learning_phase(): 0})
print('Found {} boxes for {}'.format(len(out_boxes), image_file))
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Use one of the functions you've implemented to perform Non-max suppression with a threshold of iou_threshold (≈1 line)
scores, boxes, classes = yolo_non_max_suppression(
scores,
boxes,
classes,
max_boxes=max_boxes,
iou_threshold=iou_threshold)
return scores, boxes, classes
pather = "/home/robot-tumas/Desktop/projects/Class/find-people/"
#Load pre_trained model
sess = K.get_session()
class_names = read_classes(pather + "classes.txt")
image_shape = (720., 1280.)
yolo_model = load_model(pather + "compModel.pb")
#yolo_model.summary()
yolo_outputs = yolo_head(tf.convert_to_tensor(yolo_model.output), anchors,
len(class_names))
input_image_shape = K.placeholder(shape=(2, ))
scores, boxes, classes = yolo_eval(yolo_outputs, input_image_shape)
import imageio
def predict(sess, image_file):
# Preprocess your image
image, image_data = preprocess_image(image_file,
model_image_size=(608, 608))
box_class_probs,
score_threshold)
boxes = scale_boxes(boxes, image_shape)
scores, boxes, classes = yolo_non_max_suppression(scores, boxes, classes,
max_boxes, iou_threshold)
return scores, boxes, classes
#3 - Test YOLO pretrained model on images
sess = K.get_session()
#3.1 - Defining classes, anchors and image shape.
class_names = read_classes('C:/Users/kobe24/yad2k/model_data/coco_classes.txt')
anchors = read_anchors('C:/Users/kobe24/yad2k/model_data/yolo_anchors.txt')
image_shape = (300., 450.)
#3.2 - Loading a pretrained model
yolo_model = load_model('C:/Users/kobe24/yad2k/model_data/yolo.h5')
#yolo_model.summary()
#3.3 - Convert output of the model to usable bounding box tensors
yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))
#3.4 - Filtering boxes
scores, boxes, classes = yolo_eval(yolo_outputs, image_shape)
#3.5 - Run the graph on an image
# 保存已经绘制了边界框的图
# image.save(os.path.join("out", image_file), quality=100)
cv2.imshow('Image', np.array(image))
# 打印出已经绘制了边界框的图
if is_plot:
output_image = scipy.misc.imread(os.path.join("out", image_file))
plt.imshow(output_image)
return out_scores, out_boxes, out_classes
'''定义分类, 锚框与图像维度'''
class_names = yolo_utils.read_classes(
"model_data/coco_classes.txt") # 读入类别标签文本
anchors = yolo_utils.read_anchors(
"model_data/yolo_anchors.txt") # 读入锚框尺寸(w,h), 共五种锚框
image_shape = (720., 1280.)
yolo_model = load_model("model_data/yolov2.h5") # 加载训练模型(该模块位于keras模块下)
yolo_outputs = yolo_head(yolo_model.output, anchors,
len(class_names)) # 将模型的输出转化为边界框
scores, boxes, classes = yolo_eval(yolo_outputs, image_shape) # 过滤锚框
# 将视频文件转化为图像进行处理
vc = cv2.VideoCapture("video/test_video1.mp4")
totalFrameNumber = vc.get(7) # 获取总视频帧数
c = 1
step = 3 # 定义帧数间隔
if vc.isOpened():
rval, frame = vc.read()
else:
