def predict(sess, image_file):
"""
Runs the graph stored in "sess" to predict boxes for "image_file". Prints and plots the preditions.
Arguments:
sess -- your tensorflow/Keras session containing the YOLO graph
image_file -- name of an image stored in the "images" folder.
Returns:
out_scores -- tensor of shape (None, ), scores of the predicted boxes
out_boxes -- tensor of shape (None, 4), coordinates of the predicted boxes
out_classes -- tensor of shape (None, ), class index of the predicted boxes
"""
# Preprocess your image
image, image_data = preprocess_image("images/" + image_file, model_image_size = (608, 608))
out_scores, out_boxes, out_classes = None
# Print predictions info
print('Found {} boxes for {}'.format(len(out_boxes), image_file))
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
# Save the predicted bounding box on the image
image.save(os.path.join("out", image_file), quality=90)
# Display the results in the notebook
output_image = scipy.misc.imread(os.path.join("out", image_file))
imshow(output_image)
return out_scores, out_boxes, out_classes
def predict(sess, image_file):
"""
Runs the graph stored in "sess" to predict boxes for "image_file". Prints and plots the predictions.
Arguments:
sess -- your tensorflow/Keras session containing the YOLO graph
image_file -- name of an image stored in the "images" folder.
Returns:
out_scores -- tensor of shape (None, ), scores of the predicted boxes
out_boxes -- tensor of shape (None, 4), coordinates of the predicted boxes
out_classes -- tensor of shape (None, ), class index of the predicted boxes
Note: "None" actually represents the number of predicted boxes, it varies between 0 and max_boxes.
"""
# Preprocess your image
image, image_data = preprocess_image("images/" + image_file,
model_image_size=(608, 608))
# Run the session with the correct tensors and choose the correct placeholders in the feed_dict.
# You'll need to use feed_dict={yolo_model.input: ... , K.learning_phase(): 0})
### START CODE HERE ### (≈ 1 line)
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes],
feed_dict={
yolo_model.input:
image_data,
K.learning_phase(): 0
})
### END CODE HERE ###
# Print predictions info
print('Found {} boxes for {}'.format(len(out_boxes), image_file))
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
# Save the predicted bounding box on the image
image.save(os.path.join("out", image_file), quality=90)
# Display the results in the notebook
output_image = scipy.misc.imread(os.path.join("out", image_file))
imshow(output_image)
return out_scores, out_boxes, out_classes
def predict_cv2(sess, image_file, delta_time):
"""
Runs the graph stored in "sess" to predict boxes for "image_file". Prints and plots the preditions.
Arguments:
sess -- your tensorflow/Keras session containing the YOLO graph
image_file -- name of an image stored in the "images" folder.
Returns:
out_scores -- tensor of shape (None, ), scores of the predicted boxes
out_boxes -- tensor of shape (None, 4), coordinates of the predicted boxes
out_classes -- tensor of shape (None, ), class index of the predicted boxes
Note: "None" actually represents the number of predicted boxes, it varies between 0 and max_boxes.
"""
# Preprocess your image
image, image_data = preprocess_image("images/" + image_file,
model_image_size=(608, 608))
# Run the session with the correct tensors and choose the correct placeholders in the feed_dict.
out_scores, out_boxes, out_classes = sess.run(
fetches=[scores, boxes, classes],
feed_dict={
yolo_model.input: image_data,
K.learning_phase(): 0
})
# Print predictions info
print('Found {} boxes for {}'.format(len(out_boxes), image_file))
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
#scale_boxes(boxes, image.size)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
# Save the predicted bounding box on the image
image.save(os.path.join("out", image_file), quality=90)
# Display the results in the notebook
#output_image = scipy.misc.imread(os.path.join("out", image_file))
output_image = cv2.imread(os.path.join("out", image_file))
delta_time = int(delta_time * 1000)
cv2.putText(output_image, str(delta_time), (200, 200),
cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 2)
cv2.imshow("predictions", output_image)
return out_scores, out_boxes, out_classes
def predict(sess, image_file):
# 对图片预处理, image_data 会增加一个维度, 变成 (1, 608, 608, 3), 这将作为CNN的输入
image, image_data = preprocess_image("images/" + image_file, model_image_size = (608, 608))
# 喂入数据, 运行 session
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))
colors = generate_colors(class_names)
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
image.save(os.path.join("out", image_file), quality=90)
output_image = scipy.misc.imread(os.path.join("out", image_file))
imshow(output_image)
plt.show()
return out_scores, out_boxes, out_classes
def loop(self):
fpgaOutputShapes = []
for idx in range(len( self.output_shapes)):
fpgaOutputShape_l = self.output_shapes[idx]
fpgaOutputShape_l[0] = self.args['batch_sz']
fpgaOutputShapes.append(fpgaOutputShape_l)
if self.args['yolo_version'] == 'v2': self.yolo_postproc = yolo.yolov2_postproc
elif self.args['yolo_version'] == 'v3': self.yolo_postproc = yolo.yolov3_postproc
self.biases = bias_selector(self.args)
self.labels = xdnn_io.get_labels(self.args['labels'])
self.colors = generate_colors(len(self.labels))
while True:
read_slot = self._shared_output_arrs.openReadId()
if read_slot is None:
break
read_slot_arrs = self._shared_output_arrs.accessNumpyBuffer(read_slot)
imgList = []
shape_list = []
#image_id = self._qFrom.get()
num_images = (read_slot_arrs[-1].shape)[0]
for image_num in range(num_images):
image_id = read_slot_arrs[-1][image_num][0]
if image_id == -1:
break
imgList.append(self.img_paths[int(image_id)])
shape_list.append(read_slot_arrs[-1][image_num][1:4])
if self.args["benchmarkmode"]:
self.numProcessed += len(imgList)
#self.streamQ.put(sId)
self._shared_output_arrs.closeReadId(read_slot)
continue
self.run(imgList,read_slot_arrs[0:-1], fpgaOutputShapes, shape_list)
self._shared_output_arrs.closeReadId(read_slot)
self.finish()
def predict(sess, image_file):
image, image_data = preprocess_image(image_file,
model_image_size=(608, 608))
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes], {
yolo_model.input: image_data,
K.learning_phase(): 0
})
print('Found {} boxes for {}'.format(len(out_boxes), image_file))
colors = generate_colors(class_names)
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
image.save(os.path.join(r"C:\Users\User\Desktop\Project2", image_file),
quality=90)
output_image = scipy.misc.imread(
os.path.join(r"C:\Users\User\Desktop\Project2", image_file))
imshow(output_image)
return out_scores, out_boxes, out_classes
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})
### END CODE HERE ###
print('Found {} boxes for {}'.format(len(out_boxes), image_file))
colors = generate_colors(class_names)
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
image.save(os.path.join('out', image_file), quality = 90)
output_image = scipy.misc.imread(os.path.join('out', image_file))
imshow(output_image)
return out_scores, out_boxes, out_classes
def predict(sess, image_file):
# Preprocess your image
image, image_data = preprocess_image("images/" + image_file, model_image_size = (608, 608))
# Running 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 predictions info
print('Found {} boxes for {}'.format(len(out_boxes), image_file))
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
# Save the predicted bounding box on the image
image.save(os.path.join("out", image_file), quality=90)
output_image = scipy.misc.imread(os.path.join("out", image_file))
imshow(output_image)
return out_scores, out_boxes, out_classes
def _run(self, imgList, imgShape, fpgaOutput):
if self.numProcessed == 0:
self.startTime = timeit.default_timer()
self.labels = xdnn_io.get_labels(self._args['labels'])
self.colors = generate_colors(len(self.labels))
self.zmqPub = None
if self._args['zmqpub']:
self.zmqPub = ZmqResultPublisher(self._args['deviceID'])
self.goldenMap = None
if self._args['golden']:
#self.goldenMap = xdnn_io.getGoldenMap(self._args['golden'])
self.top5Count = 0
self.top1Count = 0
bboxes = yolo.yolov2_postproc([fpgaOutput],
self._args,
imgShape,
biases=self.biases)
#if self._args['servermode']:
return bboxes
def predict(sess, image_file):
"""
Runs the graph stored in "sess" to predict boxes for "image_file". Prints and plots the preditions.
Arguments:
sess -- your tensorflow/Keras session containing the YOLO graph
image_file -- name of an image stored in the "images" folder.
Returns:
out_scores -- tensor of shape (None, ), scores of the predicted boxes
out_boxes -- tensor of shape (None, 4), coordinates of the predicted boxes
out_classes -- tensor of shape (None, ), class index of the predicted boxes
Note: "None" actually represents the number of predicted boxes, it varies between 0 and max_boxes.
"""
# Preprocess your image
image, image_data = preprocess_image("images/" + image_file, model_image_size = (608, 608))
# Run the session with the correct tensors and choose the correct placeholders in the feed_dict.
# You'll need to use feed_dict={yolo_model.input: ... , K.learning_phase(): 0})
### START CODE HERE ### (≈ 1 line)
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes], feed_dict={yolo_model.input: image_data,
K.learning_phase(): 0})
### END CODE HERE ###
# Print predictions info
print('Found {} boxes for {}'.format(len(out_boxes), image_file))
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
# Save the predicted bounding box on the image
image.save(os.path.join("out", image_file), quality=90)
# Display the results in the notebook
output_image = scipy.misc.imread(os.path.join("out", image_file))
imshow(output_image)
return out_scores, out_boxes, out_classes
def predict(sess, image_file):
"""
Runs the graph stored in "sess" to predict boxes for "image_file". Prints and plots the preditions.
Arguments:
sess -- your tensorflow/Keras session containing the YOLO graph
image_file -- name of an image stored in the "images" folder.
Returns:
out_scores -- tensor of shape (None, ), scores of the predicted boxes
out_boxes -- tensor of shape (None, 4), coordinates of the predicted boxes
out_classes -- tensor of shape (None, ), class index of the predicted boxes
Note: "None" actually represents the number of predicted boxes, it varies between 0 and max_boxes.
"""
# np.savetxt("output.txt", dept_array, fmt="%i")
# print(dept_array)
if image_file.__class__ == str:
image, image_data = preprocess_image("images/" + image_file,
model_image_size=(416, 416))
else:
image = PIL.Image.fromarray(image_file)
image, image_data = preprocess_image(image,
model_image_size=(416, 416))
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)
# Draw bounding boxes on the image file
labels = draw_boxes(image, out_scores, out_boxes, out_classes, class_names,
colors)
return out_scores, out_boxes, out_classes, image, labels
def predict(sess, image_file):
# Preprocess your image
image, image_data = preprocess_image("images/" + image_file, model_image_size = (608, 608))
# Run the session with the correct tensors and choose the correct placeholders in the feed_dict.
# You'll need to use feed_dict={yolo_model.input: ... , K.learning_phase(): 0})
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes], feed_dict={yolo_model.input:image_data, K.learning_phase():0})
# Print predictions info
print('Found {} boxes for {}'.format(len(out_boxes), image_file))
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
# Save the predicted bounding box on the image
image.save(os.path.join("out", image_file), quality=90)
# Display the results in the notebook
output_image = scipy.misc.imread(os.path.join("out", image_file))
imshow(output_image)
return out_scores, out_boxes, out_classes
def predict(sess, image_file):
image, image_data = preprocess_image("in2/" + image_file,
model_image_size=(416, 416))
# Run the yolo model
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes],
feed_dict={
yolo_model.input:
image_data,
K.learning_phase(): 0
})
colors = generate_colors(class_names)
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
image.save(os.path.join("out8", image_file), quality=90)
output_image = scipy.misc.imread(os.path.join("out8", image_file))
return out_scores, out_boxes, out_classes
def predict(sess, image_file):
# Preprocess your image
image, image_data = preprocess_image("images/" + image_file,
model_image_size=(608, 608))
# Run the session with the correct tensors and choose the correct placeholders in the feed_dict.
out_scores, out_boxes, out_classes = sess.run(
fetches=[scores, boxes, classes],
feed_dict={
yolo_model.input: image_data,
K.backend.learning_phase(): 0
})
# Print predictions info
print('Found {} boxes for {}'.format(len(out_boxes), image_file))
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
# Save the predicted bounding box on the image
image.save(os.path.join("out", image_file), quality=90)
return out_scores, out_boxes, out_classes
def predict(sess, image_file):
# Preprocess your image
image, image_data = preprocess_image(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,
input_image_shape: [image.size[1], image.size[0]],
K.learning_phase(): 0
})
# Print predictions info
Filter = []
counter = 0 # counter of non humans
for i in range(len(out_classes)):
if out_classes[i] != 0:
Filter.append(False)
counter = counter + 1
else:
Filter.append(True)
numberValid = len(out_classes) - counter
for i in range(len(out_classes)):
out_classes[i] = Filter[i] * out_classes[i]
out_classes = out_classes[0:numberValid]
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
# Save the predicted bounding box on the image
image.save(os.path.join("out", image_file), quality=90)
# Display the results in the notebook
output_image = scipy.misc.imread(os.path.join("out", image_file))
imshow(output_image)
imageio.imwrite("output.jpg", output_image)
#print('output classes: ',out_classes.eval())
return out_scores, out_boxes, out_classes
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)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
# Save the predicted bounding box on the image
image.save(os.path.join("out", image_file), quality=90)
# Display the results in the notebook
output_image = scipy.misc.imread(os.path.join("out", image_file))
plt.figure(figsize=(12,12))
imshow(output_image)
return out_scores, out_boxes, out_classes
def predict_image(yolo_model, class_names, anchors, image_shape, in_dir, out_dir, image_name, score_th=0.6):
print('_'*40)
print('Processing ', image_name)
# Step 1 - Preprocess input image
# Yolo requires 608x608 size
image, image_data = preprocess_image(in_dir+image_name, model_image_size = (608, 608))
# Step 2 - Define Tensorflow computation graph
# The output of yolo_model is a (m, 19, 19, 5, 85) tensor that needs to
# pass through non-trivial processing and conversion.
# yolo_head function from yad2k does that for you.
yolo_output_good = yolo_head(yolo_model.output, anchors, len(class_names))
# Convert the output of YOLO encoding (a lot of boxes)
# to the predicted boxes along with their scores, box coordinates and classes
scores, boxes, classes = yolo_eval(yolo_output_good, image_shape, max_boxes=10, score_threshold=score_th, iou_threshold=.5)
# Step 3 - Run TF session
sess = K.get_session()
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes],
feed_dict={yolo_model.input: image_data, K.learning_phase(): 0})
# output:
# out_scores -- tensor of shape (None, ), scores of the predicted boxes
# out_boxes -- tensor of shape (None, 4), coordinates of the predicted boxes
# out_classes -- tensor of shape (None, ), class index of the predicted boxes
print('Found {} boxes for {}'.format(len(out_boxes), image_name))
# Step 4 - Generate the output image
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
# Save the predicted bounding box on the image
image.save(out_dir+image_name, quality=100)
print('Saved new', image_name)
def predict(sess, image_file, is_show_info=True, is_plot=True):
"""
运行存储在sess的计算图以预测image_file的边界框，打印出预测的图与信息。
参数：
sess - 包含了YOLO计算图的TensorFlow/Keras的会话。
image_file - 存储在images文件夹下的图片名称
返回：
out_scores - tensor类型，维度为(None,)，锚框的预测的可能值。
out_boxes - tensor类型，维度为(None,4)，包含了锚框位置信息。
out_classes - tensor类型，维度为(None,)，锚框的预测的分类索引。
"""
#图像预处理
image, image_data = yolo_utils.preprocess_image(r"E:\深度学习\第四课第三周编程作业\Car detection for Autonomous Driving\images\\" + image_file, model_image_size = (608, 608))
#运行会话并在feed_dict中选择正确的占位符.
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes], feed_dict = {yolo_model.input:image_data, K.learning_phase(): 0})
#打印预测信息
if is_show_info:
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
def predict(sess, image_file):
"""
Runs the graph stored in "sess" to predict boxes for "image_file". Prints and plots the preditions.
Arguments:
sess -- your tensorflow/Keras session containing the YOLO graph
image_file -- name of an image stored in the "images" folder.
Returns:
out_scores -- tensor of shape (None, ), scores of the predicted boxes
out_boxes -- tensor of shape (None, 4), coordinates of the predicted boxes
out_classes -- tensor of shape (None, ), class index of the predicted boxes
Note: "None" actually represents the number of predicted boxes, it varies between 0 and max_boxes.
"""
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))
colors = generate_colors(class_names)
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
image.save(os.path.join("out", image_file), quality=90)
output_image = scipy.misc.imread(os.path.join("out", image_file))
imshow(output_image)
return out_scores, out_boxes, out_classes
def predict(sess, image_file):
# Runs the graph stored in "sess" to predict boxes for "image_file". Prints and plots the preditions.
# Preprocess your image
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)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
# Save the predicted bounding box on the image
image.save(os.path.join("output", image_file), quality=90)
return out_scores, out_boxes, out_classes
def predict(sess, image):
# Preprocess your image
image, image_data = preprocess_image(image,
model_image_size=(416, 416))
# Run the session with the correct tensors and choose the correct placeholders in the feed_dict.
# You'll need to use feed_dict={yolo_model.input: ... , K.learning_phase(): 0})
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes],
feed_dict={
yolo_model.input:
image_data,
K.learning_phase(): 0
})
# Print predictions info
print('Found {} boxes'.format(len(out_boxes)))
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Draw bounding boxes on the image file
out_image = draw_boxes(image, out_scores, out_boxes, out_classes,
class_names, colors)
return out_image, out_scores, out_boxes, out_classes
def yolo_pipeline(vid_frame):
# Preprocess video frame
image, image_data = preprocess_vid(vid_frame, model_image_size=(608, 608))
# Run the session with the correct tensors and choose the correct placeholders in the feed_dict.
# You'll need to use feed_dict={yolo_model.input: ... , K.learning_phase(): 0})
### START CODE HERE ### (≈ 1 line)
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes],
feed_dict={
yolo_model.input:
image_data,
K.learning_phase(): 0
})
### END CODE HERE ###
# Print predictions info
#print('Found {} boxes'.format(len(out_boxes)))
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
return np.asarray(image)
def predict(sess, image_file):
'''
The function will run the graph stored in "sess" to predict boxes for "image_file". Prints and plots the preditions.
'''
# processing the image data
image, image_data = preprocess_image("images/" + image_file,
model_image_size=(608, 608))
# Runing the session with the correct tensors and choose the correct placeholders in the feed_dict.
# We will need to use feed_dict={yolo_model.input: ... , K.learning_phase(): 0})
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes],
feed_dict={
yolo_model.input:
image_data,
K.learning_phase(): 0
})
# Print predictions info
print('Found {} boxes for {}'.format(len(out_boxes), image_file))
# Generating colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Draw bounding boxes on the image file
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
# saving the image
image.save(os.path.join("out", image_file), quality=90)
# displaying the image
img = cv2.imread(os.path.join("out", "test.jpg"), 1)
cv2.imshow('output', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
return out_scores, out_boxes, out_classes
def predict(sess, image_file):
"""
Predict boxes for "image_file"
Arguments:
sess -- Keras session
image_file -- name of a test image stored in the "images" folder.
Returns:
out_scores -- scores of the predicted boxes
out_boxes -- coordinates of the predicted boxes
out_classes -- class index of the predicted boxes
"""
image, image_data = preprocess_image("images/" + image_file,
model_image_size=(416, 416))
out_scores, out_boxes, out_classes = sess.run(yolo_eval(yolo_outputs),
feed_dict={
yolo_model.input:
image_data,
K.learning_phase(): 0
})
# Predictions info
# print('Found {} boxes for {}'.format(len(out_boxes), image_file))
# Generate colors for drawing bounding boxes.
colors = generate_colors(class_names)
# Draw bounding boxes on the image file
output_stats = draw_boxes(image, out_scores, out_boxes, out_classes,
class_names, colors)
# Save the predicted bounding box on the image
image.save(os.path.join("out", image_file), quality=90)
output_image = scipy.misc.imread(os.path.join("out", image_file))
return out_scores, out_boxes, out_classes, output_image, output_stats
def predict(sess, image_file, is_show_info=True, is_plot=True):
"""
运行存储在sess的计算图以预测image_file的边界框，打印出预测图与信息
:param sess: 包含了YOLO计算图的TensorFlow/keras的会话
:param imagefile: 存储images文件下的图片名称
:param is_show_info:
:param is_plot:
:return:
out_scores:tensor, (None, ),锚框的预测的可能值
out_boxes:tensor, (None,4),包含了锚框位置信息
out_classes:tensor, (None, ),锚框的预测的分类索引
"""
image, image_data = preprocess_image(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})
if is_show_info:
print("在" + str(image_file)+"中找到"+str(len(out_boxes))+"个锚框。")
colors = generate_colors(class_names)
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
image.save(os.path.join('C:\\Users\\korey\\Desktop\\car',image_file), quality=90)
if is_plot:
out_image = plt.imread(os.path.join('C:\\Users\\korey\\Desktop\\car',image_file))
plt.imshow(out_image)
plt.show()
return out_scores, out_boxes, out_classes
def predict_cv2_fast(sess, image):
"""
Runs the graph stored in "sess" to predict boxes for "image_file". Prints and plots the preditions.
Arguments:
sess -- your tensorflow/Keras session containing the YOLO graph
image_file -- name of an image stored in the "images" folder.
Returns:
out_scores -- tensor of shape (None, ), scores of the predicted boxes
out_boxes -- tensor of shape (None, 4), coordinates of the predicted boxes
out_classes -- tensor of shape (None, ), class index of the predicted boxes
Note: "None" actually represents the number of predicted boxes, it varies between 0 and max_boxes.
"""
# Preprocess your image
image, image_data = preprocess_image_cv2(image,
model_image_size=(608, 608))
# Run the session with the correct tensors and choose the correct placeholders in the feed_dict.
start_time = time.time()
out_scores, out_boxes, out_classes = sess.run(
fetches=[scores, boxes, classes],
feed_dict={
yolo_model.input: image_data,
K.learning_phase(): 0
})
end_time = time.time()
delta_time = end_time - start_time
colors = generate_colors(class_names)
draw_boxes_cv2(image, out_scores, out_boxes, out_classes, class_names,
colors)
delta_time = int(delta_time * 1000)
cv2.putText(image, str(delta_time), (200, 200), cv2.FONT_HERSHEY_SIMPLEX,
2, (255, 255, 255), 2)
cv2.imshow("predictions", image)
return out_scores, out_boxes, out_classes
def predictFromImg(sess, image, scores, boxes, classes, yolo_model,
class_names):
# preprocess_image
model_image_size = (608, 608)
resized_image = image.resize(tuple(reversed(model_image_size)),
Image.BICUBIC)
image_data = np.array(resized_image, dtype='float32')
image_data /= 255.
image_data = np.expand_dims(image_data, 0) # Add batch dimension.
out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes],
feed_dict={
yolo_model.input:
image_data,
K.learning_phase(): 0
})
colors = generate_colors(class_names)
draw_boxes_2(image, out_scores, out_boxes, out_classes, class_names,
colors)
return out_scores, out_boxes, out_classes
def predict(sess, image_file):
"""
Returns:
out_scores -- tensor of shape (None, ), scores of the predicted boxes
out_boxes -- tensor of shape (None, 4), coordinates of the predicted boxes
out_classes -- tensor of shape (None, ), class index of the predicted boxes
"""
image, image_data = preprocess_image("image/" + 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))
colors = generate_colors(class_names)
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
image.save(os.path.join("out", image_file), quality=90)
output_image = scipy.misc.imread(os.path.join("out", image_file))
plt.imshow(output_image)
plt.show()
return out_scores, out_boxes, out_classes
def __init__(self,
batch_sz=10,
in_shape=[3, 608, 608],
quantizecfg="yolo_deploy_608.json",
xclbin=None,
netcfg="yolo.cmds",
datadir="yolov2.caffemodel_data",
labels="coco.names",
xlnxlib="libxfdnn.so",
firstfpgalayer="conv0",
classes=80,
verbose=False):
if verbose:
log.basicConfig(format="%(levelname)s: %(message)s",
level=log.DEBUG)
log.info("Running with verbose output")
else:
log.basicConfig(format="%(levelname)s: %(message)s")
if xclbin is None:
log.error(
"XYOLO initialized without reference to xclbin, please set this before calling detect!!"
)
sys.exit(1)
self.xdnn_handle = None
log.info("Reading labels...")
with open(labels) as f:
names = f.readlines()
self.names = [x.strip() for x in names]
# Arguments exposed to user
self.in_shape = in_shape
self.quantizecfg = quantizecfg
self.xclbin = xclbin
self.netcfg = netcfg
self.datadir = datadir
self.labels = labels
self.xlnxlib = xlnxlib
self.batch_sz = batch_sz
self.firstfpgalayer = firstfpgalayer # User may be using their own prototxt w/ unique names
self.classes = classes # User may be using their own prototxt with different region layer
# Arguments not exposed to user
## COCO categories are not sequential
self.cats = [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 27, 28, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 67, 70, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 84, 85, 86, 87, 88, 89, 90
]
self.images = None
self.scaleA = 10000
self.scaleB = 30
self.PE = -1
self.transform = "yolo" # XDNN_IO will scale/letterbox the image for YOLO network
self.img_mean = "0,0,0"
self.net_w = self.in_shape[1]
self.net_h = self.in_shape[2]
self.out_w = self.out_h = (self.net_w / 32)
self.bboxplanes = 5
#self.classes = 80
self.scorethresh = 0.24
self.iouthresh = 0.3
self.groups = self.out_w * self.out_h
self.coords = 4
self.groupstride = 1
self.batchstride = (self.groups) * (self.classes + self.coords + 1)
self.beginoffset = (self.coords + 1) * (self.out_w * self.out_h)
self.outsize = (self.out_w * self.out_h *
(self.bboxplanes + self.classes)) * self.bboxplanes
self.colors = generate_colors(
self.classes) # Generate color pallette for drawing boxes
config = vars(self)
self.q_fpga = Queue(maxsize=1)
self.q_bbox = Queue(maxsize=1)
self.proc_fpga = Process(target=self.fpga_stage,
args=(config, self.q_fpga, self.q_bbox))
self.proc_bbox = Process(target=self.bbox_stage,
args=(config, self.q_bbox))
self.proc_fpga.start()
self.proc_bbox.start()
log.info("Running network input %dx%d and output %dx%d" %
(self.net_w, self.net_h, self.out_w, self.out_h))
Image.BICUBIC)
image_data = np.array(resized_image, dtype='float32')
image_data /= 255.
image_data = np.expand_dims(image_data, 0) # Add batch dimension.
b = BytesIO()
img.save(b, format="jpeg")
image = Image.open(b)
out_scores, out_boxes, out_classes = sess.run(
[scores, boxes, classes],
feed_dict={
yolo_model.input: image_data,
input_image_shape: [image.size[1], image.size[0]],
K.learning_phase(): 0
})
colors = generate_colors(class_names)
draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
image = np.array(image)
cv2.imshow('RGB image', image)
# cv2.imshow('RGB image',frame)
if cv2.waitKey(20) & 0xFF == ord('q'):
break
# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()
# import freenect
# import cv2
# import numpy as np
def run(rundir, chanIdx, q, args):
xspub = xstream.Publisher()
xssub = xstream.Subscribe(chanIdx2Str(chanIdx))
runner = Runner(rundir)
inTensors = runner.get_input_tensors()
outTensors = runner.get_output_tensors()
q.put(1) # ready for work
fpgaBlobs = None
labels = xdnn_io.get_labels(args['labels'])
if args['yolo_version'] == 'v2': yolo_postproc = yolo.yolov2_postproc
elif args['yolo_version'] == 'v3': yolo_postproc = yolo.yolov3_postproc
else:
assert args['yolo_version'] in (
'v2', 'v3'), "--yolo_version should be <v2|v3>"
biases = bias_selector(args)
if (args['visualize']): colors = generate_colors(len(labels))
while True:
try:
payload = xssub.get()
if not payload:
break
(meta, buf) = payload
if fpgaBlobs == None:
# allocate buffers
fpgaBlobs = []
batchsz = meta['shape'][0] # inTensors[0].dims[0]
for io in [inTensors, outTensors]:
blobs = []
for t in io:
shape = (batchsz, ) + tuple(
[t.dims[i] for i in range(t.ndims)][1:])
blobs.append(
np.empty((shape), dtype=np.float32, order='C'))
fpgaBlobs.append(blobs)
fcOutput = np.empty((
batchsz,
args['outsz'],
),
dtype=np.float32,
order='C')
fpgaInput = fpgaBlobs[0][0]
assert (tuple(meta['shape']) == fpgaInput.shape)
data = np.frombuffer(buf,
dtype=np.float32).reshape(fpgaInput.shape)
np.copyto(fpgaInput, data)
jid = runner.execute_async(fpgaBlobs[0], fpgaBlobs[1])
runner.wait(jid)
boxes = yolo_postproc(fpgaBlobs[1],
args,
meta['image_shapes'],
biases=biases)
if (not args['profile']):
for i in range(min(batchsz, len(meta['image_shapes']))):
print("Detected {} boxes in {}".format(
len(boxes[i]), meta['images'][i]),
flush=True)
# Save the result
if (args['results_dir']):
for i in range(min(batchsz, len(meta['image_shapes']))):
fname = meta['images'][i]
filename = os.path.splitext(os.path.basename(fname))[0]
out_file_txt = os.path.join(args['results_dir'],
filename + '.txt')
print("Saving {} boxes to {}".format(
len(boxes[i]), out_file_txt))
sys.stdout.flush()
saveDetectionDarknetStyle(out_file_txt, boxes[i],
meta['image_shapes'][i])
if (args['visualize']):
out_file_png = os.path.join(
args['results_dir'], filename + '.png')
print("Saving result to {}".format(out_file_png))
sys.stdout.flush()
draw_boxes(fname, boxes[i], labels, colors,
out_file_png)
if meta['id'] % 1000 == 0:
print("Recvd query %d" % meta['id'])
sys.stdout.flush()
del data
del buf
del payload
xspub.send(meta['from'], "success")
except Exception as e:
logging.error("Worker exception " + str(e))
def run(args=None):
if not args:
parser = xdnn_io.default_parser_args()
parser = yolo_parser_args(parser)
parser.add_argument('--startxstream',
default=True,
action='store_true',
help='automatically start obj store server')
parser.add_argument('--servermode',
default=False,
action='store_true',
help='accept images from another process')
parser.add_argument("--deploymodel",
type=str,
default='',
help='Original prototxt')
parser.add_argument("--caffemodel",
type=str,
default='',
help='Original caffemodel')
args = parser.parse_args()
args = xdnn_io.make_dict_args(args)
args['preprocseq'] = [('resize', (224, 224)),
('meansub', [104.007, 116.669, 122.679]),
('chtranspose', (2, 0, 1))]
if (args['golden'] or args['visualize']):
assert args['labels'], "Provide --labels to compute mAP."
assert args[
'results_dir'], "For accuracy measurements, provide --results_dir to save the detections."
labels = xdnn_io.get_labels(args['labels'])
colors = generate_colors(len(labels))
args['startxstream'] = True
args['servermode'] = False
timerQ = Queue()
args['timerQ'] = timerQ
compJson = xdnn.CompilerJsonParser(args['netcfg'])
firstInputShape = next(itervalues(compJson.getInputs()))
args['net_h'] = firstInputShape[2]
args['net_w'] = firstInputShape[3]
# start object store
# (make sure to 'pip install pyarrow')
xserver = None
if args['startxstream']:
xserver = xstream.Server()
graph = grapher.Graph("yolo_v2")
graph.node("prep", yolov2_pre.Node, args)
graph.node("fpga", yolov2_fpga.Node, args)
graph.node("post", yolov2_post.Node, args)
graph.edge("START", None, "prep")
graph.edge("prep", "prep", "fpga")
graph.edge("fpga", "fpga", "post")
graph.edge("DONE", "post", "fpga")
graph.edge("DONE", "post", None)
if not args['servermode']:
graph.serve(background=True)
img_paths = xdnn_io.getFilePaths(args['images'])
reqProc = mp.Process(target=request_process,
args=(
args,
img_paths,
graph._in[0],
graph._out[0],
))
t = timeit.default_timer()
reqProc.start()
reqProc.join()
graph.stop(kill=False)
t2 = args['timerQ'].get()
full_time = t2 - t
args['timerQ'].close()
print("Total time : {}s for {} images".format(full_time,
len(img_paths)))
print("Average FPS : {} imgs/sec".format(len(img_paths) / full_time))
else:
print("Serving %s -> %s" % (graph._in[0], graph._out[0]))
graph.serve()
# mAP calculation
if (args['golden']):
print(flush=True)
print("Computing mAP score : ", flush=True)
print("Class names are : {} ".format(labels), flush=True)
mAP = calc_detector_mAP(args['results_dir'], args['golden'], len(labels), labels,\
args['prob_threshold'], args['mapiouthresh'], args['points'])
sys.stdout.flush()
