def predict(self, image):
org_image = np.copy(image)
org_h, org_w, _ = org_image.shape
image_data = utils.image_preporcess(image,
[self.input_size, self.input_size])
image_data = image_data[np.newaxis, ...]
pred_sbbox, pred_mbbox, pred_lbbox, layer_n = self.sess.run(
[
self.pred_sbbox, self.pred_mbbox, self.pred_lbbox,
self.layer_num
],
feed_dict={
self.input: image_data,
self.trainable: False
})
pred_bbox = np.concatenate([
np.reshape(pred_sbbox, (-1, 5 + self.num_classes)),
np.reshape(pred_mbbox, (-1, 5 + self.num_classes)),
np.reshape(pred_lbbox, (-1, 5 + self.num_classes))
],
axis=0)
bboxes = utils.postprocess_boxes(pred_bbox, (org_h, org_w),
self.input_size, self.score_threshold)
bboxes = utils.nms(bboxes, self.iou_threshold)
return org_h, org_w, pred_bbox, bboxes, layer_n
def predict(self, image):
'''
预测结果
:param image: 图片数据，shape为[800,600,3]
:return:
bboxes：食材检测预测框结果，格式为：[x_min, y_min, x_max, y_max, probability, cls_id],
layer_n[0]：烤层检测结果，0：最下层、1：中间层、2：最上层、3：其他
'''
org_image = np.copy(image)
org_h, org_w, _ = org_image.shape
image_data = utils.image_preporcess(image, [self.input_size, self.input_size])
image_data = image_data[np.newaxis, ...]
pred_sbbox, pred_mbbox, pred_lbbox, layer_n = self.sess.run(
[self.pred_sbbox, self.pred_mbbox, self.pred_lbbox, self.layer_num],
feed_dict={
self.input: image_data,
self.trainable: False
}
)
pred_bbox = np.concatenate([np.reshape(pred_sbbox, (-1, 5 + self.num_classes)),
np.reshape(pred_mbbox, (-1, 5 + self.num_classes)),
np.reshape(pred_lbbox, (-1, 5 + self.num_classes))], axis=0)
bboxes = utils.postprocess_boxes(pred_bbox, (org_h, org_w), self.input_size, self.score_threshold)
bboxes = utils.nms(bboxes, self.iou_threshold)
return bboxes, layer_n[0]
def cam(self, sml_type):
image = cv2.imread(self.img_path) # 图片读取
org_image = np.copy(image)
org_h, org_w, _ = org_image.shape
image_data = utils.image_preporcess(image,
[Y.input_size, Y.input_size])
image_data = image_data[np.newaxis, ...]
pred_sbbox, pred_pre_sbbox, pred_mbbox, pred_pre_mbbox, pred_lbbox, pred_pre_lbbox, layer_num_pre, layer_n = Y.sess.run(
[
Y.pred_sbbox, Y.pred_pre_sbbox, Y.pred_mbbox, Y.pred_pre_mbbox,
Y.pred_lbbox, Y.pred_pre_lbbox, Y.layer_num_pre, Y.layer_num
],
feed_dict={
Y.input: image_data,
Y.trainable: False
})
typ_dict = {"l": "conv_lbbox", "m": "conv_mbbox", "s": "conv_sbbox"}
pre_dict = {
"l": pred_pre_lbbox[0],
"m": pred_pre_mbbox[0],
"s": pred_pre_sbbox[0]
}
size_dict = {"l": 1024, "m": 512, "s": 256}
pred_bbox = np.concatenate([
np.reshape(pred_sbbox, (-1, 5 + Y.num_classes)),
np.reshape(pred_mbbox, (-1, 5 + Y.num_classes)),
np.reshape(pred_lbbox, (-1, 5 + Y.num_classes))
],
axis=0)
best_bboxes = self.get_top_cls(pred_bbox, org_h, org_w,
2) # 获取top_n类别和置信度
print(best_bboxes)
classes = list(dict(best_bboxes).keys())[0]
print("classes::::::::::", classes)
reader = Y.reader
lbbox_w = reader.get_tensor("{}/weight".format(typ_dict[sml_type]))
lbbox_w = lbbox_w.reshape(
(int(size_dict[sml_type]), 3, 5 + Y.num_classes))
lbbox_w = lbbox_w[:, :, 5 + classes]
lbbox_w = np.sum(lbbox_w, 1)
heatmap_lbbox = np.multiply(pre_dict[sml_type], lbbox_w)
return heatmap_lbbox
def predict(self, image):
image = cv2.imread(image) # 图片读取
org_image = np.copy(image)
org_h, org_w, _ = org_image.shape
image_data = utils.image_preporcess(image, [self.input_size, self.input_size])
image_data = image_data[np.newaxis, ...]
layer_ = self.sess.run(
[self.layer_num],
feed_dict={
self.input: image_data,
self.trainable: False
}
)
layer_n = layer_ # 烤层结果
return layer_n
def predict(self, image_path):
image = cv2.imread(image_path) # 图片读取
org_image = np.copy(image)
org_h, org_w, _ = org_image.shape
image_data = utils.image_preporcess(image,
[self.input_size, self.input_size])
image_data = image_data[np.newaxis, ...]
pred_sbbox, pred_mbbox, pred_lbbox, layer_n = self.sess.run(
[
self.pred_sbbox, self.pred_mbbox, self.pred_lbbox,
self.layer_num
],
feed_dict={
self.input: image_data,
self.trainable: False
})
print("pred_bbox.shape::::::", pred_sbbox.shape)
def parse_annotation(self, annotation):
line = annotation.split()
image_path = line[0]
if not os.path.exists(image_path):
raise KeyError("%s does not exist ... " % image_path)
image = Image.open(image_path)
if self.data_aug:
if random.random() < 0.5:
image = ImageEnhance.Contrast(image) # 对比度增强
image = image.enhance(random.uniform(0.6,
1.2)) # 增强系数[0.6, 1.2]
if random.random() < 0.5:
image = ImageEnhance.Brightness(image) # 亮度调整
image = image.enhance(random.uniform(0.7,
1.2)) # 亮度调整系数[0.7, 1.2]
if random.random() < 0.5:
image = ImageEnhance.Sharpness(image) # 锐度调整
image = image.enhance(random.uniform(0.8,
1.8)) # 调整系数[0.8, 1.8]
image = np.array(image)
# image = np.array(cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_RGB2HSV)) # RGB空间转为HSV空间
layer_label = int(line[1])
bboxes = np.array([list(map(int, box.split(','))) for box in line[2:]])
if self.data_aug:
image, bboxes = self.random_horizontal_flip(
np.copy(image), np.copy(bboxes))
image, bboxes = self.random_crop(np.copy(image), np.copy(bboxes))
image, bboxes = self.random_translate(np.copy(image),
np.copy(bboxes))
image, bboxes = utils.image_preporcess(
np.copy(image), [self.train_input_size, self.train_input_size],
np.copy(bboxes))
return image, layer_label, bboxes
def predict(self, image):
'''
:param image: 图片数据
:return: std_result：食材结果[name, flag, num_label]
, layer_n:烤层结果，0：下层、1：中层、2：上层、3：其他
'''
org_image = np.copy(image)
org_h, org_w, _ = org_image.shape
image_data = utils.image_preporcess(image,
[self.input_size, self.input_size])
image_data = image_data[np.newaxis, ...]
pred_sbbox, pred_mbbox, pred_lbbox, layer_ = self.sess.run(
[
self.pred_sbbox, self.pred_mbbox, self.pred_lbbox,
self.layer_num
],
feed_dict={
self.input: image_data,
self.trainable: False
})
pred_bbox = np.concatenate([
np.reshape(pred_sbbox, (-1, 5 + self.num_classes)),
np.reshape(pred_mbbox, (-1, 5 + self.num_classes)),
np.reshape(pred_lbbox, (-1, 5 + self.num_classes))
],
axis=0)
bboxes = utils.postprocess_boxes(pred_bbox, (org_h, org_w),
self.input_size, 0.45)
bboxes = utils.nms(bboxes, self.iou_threshold)
bboxes_pr = bboxes # 检测框结果
layer_n = layer_[0] # 烤层结果
num_label = len(bboxes_pr)
# 未检测食材
if num_label == 0:
return bboxes_pr, layer_n
# 检测到一个食材
elif num_label == 1:
return bboxes_pr, layer_n
# 检测到多个食材
else:
same_label = True
for i in range(num_label):
if i == (num_label - 1):
break
if bboxes_pr[i][5] == bboxes_pr[i + 1][5]:
continue
else:
same_label = False
# 多个食材，同一标签
if same_label:
sumProb = 0.
for i in range(num_label):
sumProb += bboxes_pr[i][4]
avrProb = sumProb / num_label
bboxes_pr[0][4] = avrProb
return bboxes_pr, layer_n
# 多个食材，非同一标签
else:
sumProb = 0.
problist = list(map(lambda x: x[4], bboxes_pr))
labellist = list(map(lambda x: x[5], bboxes_pr))
labeldict = {}
for key in labellist:
labeldict[key] = labeldict.get(key, 0) + 1
# 按同种食材label数量降序排列
s_labeldict = sorted(labeldict.items(),
key=lambda x: x[1],
reverse=True)
# n_name = len(s_labeldict)
name1 = s_labeldict[0][0]
num_name1 = s_labeldict[0][1]
# 数量最多label对应的食材占比0.7以上
if num_name1 / num_label > 0.7:
num_label0 = []
for i in range(num_label):
if name1 == bboxes_pr[i][5]:
num_label0.append(bboxes_pr[i])
for i in range(len(num_label0)):
sumProb += num_label0[i][4]
avrProb = sumProb / num_label
num_label0[0][4] = avrProb
return num_label0, layer_n
# 按各个label的probability降序排序
else:
bboxes_pr = sorted(bboxes_pr,
key=lambda x: x[4],
reverse=True)
return bboxes_pr, layer_n
num_classes = 46
input_size = 416
graph = tf.Graph()
return_tensors = utils.read_pb_return_tensors(graph, pb_file, return_elements)
with tf.Session(graph=graph) as sess:
vid = cv2.VideoCapture(video_path)
while True:
return_value, frame = vid.read()
if return_value:
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
image = Image.fromarray(frame)
else:
raise ValueError("No image!")
frame_size = frame.shape[:2]
image_data = utils.image_preporcess(np.copy(frame),
[input_size, input_size])
image_data = image_data[np.newaxis, ...]
prev_time = time.time()
pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
[return_tensors[2], return_tensors[3], return_tensors[4]],
feed_dict={
return_tensors[0]: image_data,
return_tensors[1]: False
})
pred_bbox = np.concatenate([
np.reshape(pred_sbbox, (-1, 5 + num_classes)),
np.reshape(pred_mbbox, (-1, 5 + num_classes)),
np.reshape(pred_lbbox, (-1, 5 + num_classes))
],
