def __init__(self,
FLAGS,
is_training: bool,
dataset_type: str = "converted_coco"):
self.tiny = FLAGS.tiny
self.strides, self.anchors, NUM_CLASS, XYSCALE = utils.load_config(
FLAGS)
self.dataset_type = dataset_type
self.annot_path = (cfg.TRAIN.ANNOT_PATH
if is_training else cfg.TEST.ANNOT_PATH)
self.input_sizes = (cfg.TRAIN.INPUT_SIZE
if is_training else cfg.TEST.INPUT_SIZE)
self.batch_size = (cfg.TRAIN.BATCH_SIZE
if is_training else cfg.TEST.BATCH_SIZE)
self.data_aug = cfg.TRAIN.DATA_AUG if is_training else cfg.TEST.DATA_AUG
self.train_input_sizes = cfg.TRAIN.INPUT_SIZE
self.classes = utils.read_class_names(cfg.YOLO.CLASSES)
self.num_classes = len(self.classes)
self.anchor_per_scale = cfg.YOLO.ANCHOR_PER_SCALE
self.max_bbox_per_scale = 150
self.annotations = self.load_annotations()
self.num_samples = len(self.annotations)
self.num_batchs = int(np.ceil(self.num_samples / self.batch_size))
self.batch_count = 0
def __init__(self):
self.classes = utils.read_class_names(cfg.YOLO.CLASSES)
self.moving_ave_decay = cfg.YOLO.MOVING_AVE_DECAY
self.weights_path = './checkpoint/'
ckpt = tf.train.get_checkpoint_state(self.weights_path)
self.input_size = cfg.TRAIN.INPUT_SIZE
self.model_size = cfg.YOLO.MODEL_SIZE
with tf.name_scope('input'):
self.input = tf.placeholder(
dtype=tf.float32,
shape=[1, self.input_size, self.input_size, 3],
name='input')
self.training = tf.placeholder(dtype=bool, name='trainable')
model = YoloV3(inputs=self.input, training=self.training)
self.pred_bbox = model.pred_bbox
with tf.name_scope('ema'):
ema_obj = tf.train.ExponentialMovingAverage(self.moving_ave_decay)
self.sess = tf.Session(config=tf.ConfigProto(
allow_soft_placement=True))
self.sess.run(tf.global_variables_initializer())
self.saver = tf.train.Saver(ema_obj.variables_to_restore())
self.saver.restore(self.sess, ckpt.model_checkpoint_path)
def compute_loss(pred, conv, label, bboxes, i=0, CLASSES=YOLO_COCO_CLASSES):
NUM_CLASS = len(read_class_names(CLASSES))
conv_shape = tf.shape(conv)
batch_size = conv_shape[0]
output_size = conv_shape[1]
input_size = STRIDES[i] * output_size
conv = tf.reshape(conv,
(batch_size, output_size, output_size, 3, 5 + NUM_CLASS))
conv_raw_conf = conv[:, :, :, :, 4:5]
conv_raw_prob = conv[:, :, :, :, 5:]
pred_xywh = pred[:, :, :, :, 0:4]
pred_conf = pred[:, :, :, :, 4:5]
label_xywh = label[:, :, :, :, 0:4]
respond_bbox = label[:, :, :, :, 4:5]
label_prob = label[:, :, :, :, 5:]
giou = tf.expand_dims(bbox_giou(pred_xywh, label_xywh), axis=-1)
input_size = tf.cast(input_size, tf.float32)
bbox_loss_scale = 2.0 - 1.0 * label_xywh[:, :, :, :,
2:3] * label_xywh[:, :, :, :,
3:4] / (
input_size**
2)
giou_loss = respond_bbox * bbox_loss_scale * (1 - giou)
iou = bbox_iou(pred_xywh[:, :, :, :, np.newaxis, :],
bboxes[:, np.newaxis, np.newaxis, np.newaxis, :, :])
# Find the value of IoU with the real box The largest prediction box
max_iou = tf.expand_dims(tf.reduce_max(iou, axis=-1), axis=-1)
# If the largest iou is less than the threshold, it is considered that the prediction box contains no objects, then the background box
respond_bgd = (1.0 - respond_bbox) * tf.cast(
max_iou < YOLO_IOU_LOSS_THRESH, tf.float32)
conf_focal = tf.pow(respond_bbox - pred_conf, 2)
# Calculate the loss of confidence
# we hope that if the grid contains objects, then the network output prediction box has a confidence of 1 and 0 when there is no object.
conf_loss = conf_focal * (
respond_bbox * tf.nn.sigmoid_cross_entropy_with_logits(
labels=respond_bbox, logits=conv_raw_conf) +
respond_bgd * tf.nn.sigmoid_cross_entropy_with_logits(
labels=respond_bbox, logits=conv_raw_conf))
prob_loss = respond_bbox * tf.nn.sigmoid_cross_entropy_with_logits(
labels=label_prob, logits=conv_raw_prob)
giou_loss = tf.reduce_mean(tf.reduce_sum(giou_loss, axis=[1, 2, 3, 4]))
conf_loss = tf.reduce_mean(tf.reduce_sum(conf_loss, axis=[1, 2, 3, 4]))
prob_loss = tf.reduce_mean(tf.reduce_sum(prob_loss, axis=[1, 2, 3, 4]))
return giou_loss, conf_loss, prob_loss
def main(_argv):
config = ConfigProto()
# config.gpu_options.allow_growth = True
session = InteractiveSession(config=config)
# model_module = sh_digit
# if FLAGS.model == 'sh_digit':
# model_module = sh_digit
# STRIDES = model_module.STRIDES
# ANCHORS = model_module.ANCHORS
# NUM_CLASS = model_module.NUM_CLASS
# XYSCALE = model_module.XYSCALE
original_image = cv2.imread(FLAGS.image_path)
original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
image_data = cv2.resize(original_image, tuple(FLAGS.image_size_wh))
image_data = image_data / 255.
images_data = []
for i in range(1):
images_data.append(image_data)
images_data = np.asarray(images_data).astype(np.float32)
saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING])
infer = saved_model_loaded.signatures['serving_default']
batch_data = tf.constant(images_data)
pred_bbox = infer(batch_data)
for key, value in pred_bbox.items():
boxes = value[:, :, 0:4]
pred_conf = value[:, :, 4:]
print(boxes)
boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(
boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)),
scores=tf.reshape(
pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])),
max_output_size_per_class=50,
max_total_size=50,
iou_threshold=FLAGS.iou,
score_threshold=FLAGS.score
)
print(boxes.numpy())
pred_bbox = [boxes.numpy(), scores.numpy(), classes.numpy(), valid_detections.numpy()]
image = utils.draw_bbox(original_image, pred_bbox,
classes=utils.read_class_names('cfg/digit/digit.names'))
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
cv2.imshow('result', image)
cv2.waitKey()
def complete_yolov3(input_size=416,
channels=3,
training=False,
CLASSES=YOLO_COCO_CLASSES):
NUM_CLASS = len(read_class_names(CLASSES))
input_layer = tf.keras.layers.Input([input_size, input_size, channels])
conv_tensors = YOLOv3(input_layer, NUM_CLASS)
output_tensors = []
for i, conv_tensor in enumerate(conv_tensors):
pred_tensor = decode(conv_tensor, NUM_CLASS, i)
if training: output_tensors.append(conv_tensor)
output_tensors.append(pred_tensor) # len = 3
#print(output_tensors[0].shape)
YoloV3 = tf.keras.Model(input_layer, output_tensors)
return YoloV3
def __init__(self,
model_path,
names_path,
input_size=416,
treshold=0.2,
iou=0.4):
self.model_path = model_path
self.names_path = names_path
self.input_size = input_size
self.treshold = treshold
self.iou = iou
self.classes = utils.read_class_names(self.names_path)
self.num_class = len(self.classes)
self.startup_session()
print(
f'TensorFlowLiteModel initialization success! model id: {id(self)}; PID: {os.getpid()}'
)
def Create_Yolov3(input_size=416, channels=3, training=False, CLASSES=YOLO_COCO_CLASSES):
NUM_CLASS = len(read_class_names(CLASSES))
input_layer = Input([input_size, input_size, channels])
if TRAIN_YOLO_TINY:
conv_tensors = YOLOv3_tiny(input_layer, NUM_CLASS)
else:
conv_tensors = YOLOv3(input_layer, NUM_CLASS)
output_tensors = []
for i, conv_tensor in enumerate(conv_tensors):
pred_tensor = decode(conv_tensor, NUM_CLASS, i)
if training: output_tensors.append(conv_tensor)
output_tensors.append(pred_tensor)
YoloV3 = tf.keras.Model(input_layer, output_tensors)
return YoloV3
def __init__(self, dataset_type, TEST_INPUT_SIZE=TEST_INPUT_SIZE):
self.annot_path = TRAIN_ANNOT_PATH if dataset_type == 'train' else TEST_ANNOT_PATH
self.input_sizes = TRAIN_INPUT_SIZE if dataset_type == 'train' else TEST_INPUT_SIZE
self.batch_size = TRAIN_BATCH_SIZE if dataset_type == 'train' else TEST_BATCH_SIZE
self.data_aug = TRAIN_DATA_AUG if dataset_type == 'train' else TEST_DATA_AUG
self.train_input_sizes = TRAIN_INPUT_SIZE
self.strides = np.array(YOLO_STRIDES)
self.classes = read_class_names(TRAIN_CLASSES)
self.num_classes = len(self.classes)
self.anchors = (np.array(YOLO_ANCHORS).T / self.strides).T
self.anchor_per_scale = YOLO_ANCHOR_PER_SCALE
self.max_bbox_per_scale = YOLO_MAX_BBOX_PER_SCALE
self.annotations = self.load_annotations(dataset_type)
self.num_samples = len(self.annotations)
self.num_batchs = int(np.ceil(self.num_samples / self.batch_size))
self.batch_count = 0
def get_yolov4(image):
# inintial config
ANCHORS = utils.get_anchors('./data/yolov4_anchors.txt', False)
NUM_CLASS = len(utils.read_class_names('data/coco.names'))
XYSCALE = [1.2, 1.1, 1.05]
STRIDES = np.array([8, 16, 32])
input_size = 608
original_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
original_image_size = original_image.shape[:2]
image_data = image_preporcess(np.copy(original_image),
[input_size, input_size])
image_data = image_data[np.newaxis, ...].astype(np.float32)
# send grpc request
request.inputs['input_1'].CopyFrom(
tf.make_tensor_proto(image_data, dtype=types_pb2.DT_FLOAT))
result_final = []
result_future = stub.Predict(request, 10)
result_1 = result_future.outputs['tf_op_layer_concat_10']
result_final.append(np.reshape(np.array(result_1.ListFields()[2][1]), \
(1, 76, 76, 3, 6)
))
result_2 = result_future.outputs['tf_op_layer_concat_11']
result_final.append(np.reshape(np.array(result_2.ListFields()[2][1]), \
(1, 38, 38, 3, 6)
))
result_3 = result_future.outputs['tf_op_layer_concat_12']
result_final.append(np.reshape(np.array(result_3.ListFields()[2][1]), \
(1, 19, 19, 3, 6)
))
pred_bbox = utils.postprocess_bbbox(result_final, ANCHORS, STRIDES,
XYSCALE)
bboxes = utils.postprocess_boxes(pred_bbox, original_image_size,
input_size, 0.45)
bboxes = utils.nms(bboxes, 0.213, method='nms')
#image = utils.draw_bbox(original_image, bboxes)
#image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB)
#cv2.imwrite('result.jpg', image)
return bboxes
def _do_python_eval(res_prefix,
imagesetfile,
classesfile,
output_dir='output'):
filename = res_prefix + '{:s}.txt'
cachedir = os.path.join(output_dir, 'annotations_cache')
aps = []
# The PASCAL VOC metric changed in 2010
use_07_metric = False
# print ('VOC07 metric? ' + ('Yes' if use_07_metric else 'No'))
if not os.path.isdir(output_dir):
os.mkdir(output_dir)
_classes = read_class_names(classesfile)
total = 0
for i, cls in enumerate(_classes):
if cls == '__background__':
continue
rec, prec, ap, noccur = my_eval(filename,
imagesetfile,
cls,
cachedir,
ovthresh=0.5,
use_07_metric=use_07_metric)
aps += [ap]
total += noccur
print('AP for {:<10s} = {:.4f} with {:4d} views'.format(
cls, ap, noccur))
with open(os.path.join(output_dir, cls + '_pr.pkl'), 'wb') as f:
cPickle.dump({'rec': rec, 'prec': prec, 'ap': ap}, f)
print('Mean AP = {:.4f} with total {:4d} views'.format(
np.mean(aps), total))
print(' ' * 10, 'Results:')
print('-' * 30)
for i, ap in enumerate(aps):
print('{:<10s}\t{:.3f}'.format(_classes[i], ap))
print('=' * 30)
print('{:^10s}\t{:.3f}'.format('Average', np.mean(aps)))
return [res_prefix, np.mean(aps)]
def __init__(self,dataset_type):
self.annot_path = cfg['train_annot_path'] if dataset_type == 'train' else cfg['test_annot_path']
self.input_size = cfg['train_input_size'] if dataset_type == 'train' else cfg['test_input_size']
self.batch_size = cfg['train_batch_size'] if dataset_type == 'train' else cfg['test_batch_size']
self.data_aug = cfg['train_data_augement'] if dataset_type == 'train' else cfg['test_data_augement']
self.train_input_sizes = cfg['train_input_size']
self.train_input_size = random.choice(self.train_input_sizes)
self.strides = np.array(cfg['yolo_strides'])
self.classes = utils.read_class_names(cfg['yolo_classes_names'])
self.num_classes = len(self.classes)
self.anchors = np.array(utils.get_anchors(cfg['yolo_anchors']))
self.anchor_per_scale = cfg['yolo_anchor_per_scale']
self.max_bbox_per_scale = 150
self.annotations = self.load_annotation(dataset_type)
self.num_samples = len(self.annotations)
self.num_batchs = int(np.ceil(self.num_samples / self.batch_size))
self.batch_count = 0
def __init__(self, opt, datatype="train"):
self.label_path = utils.read_label_path(opt.data, datatype)
self.image_path = utils.read_image_path(opt.data, datatype)
self.classes = utils.read_class_names(opt.data)
self.input_size = opt.img_size
self.strides = np.array([8, 16, 32])
self.output_sizes = self.input_size // self.strides
self.batch_size = opt.batch_size
self.num_classes = len(self.classes)
self.max_bbox_per_scale = 150
# 读取anchors
self.anchors = np.array(utils.get_anchors(opt.data))
self.anchor_per_scale = 3
self.num_samples = len(self.label_path)
# np.ceil起到向上取整的作用
self.num_batchs = int(np.ceil(self.num_samples / self.batch_size))
self.batch_count = 0
def __init__(self, dataset_type):
self.annot_path = cfg.TRAIN.ANNOT_PATH if dataset_type == 'train' else cfg.TRAIN.ANNOT_PATH
self.input_sizes = cfg.TRAIN.INPUT_SIZE if dataset_type == 'train' else cfg.TEST.INPUT_SIZE
self.batch_size = cfg.TRAIN.BATCH_SIZE if dataset_type == 'train' else cfg.TEST.BATCH_SIZE
self.data_aug = cfg.TRAIN.DATA_AUG if dataset_type == 'train' else cfg.TEST.DATA_AUG
self.train_input_sizes = cfg.TRAIN.INPUT_SIZE
self.strides = np.array(cfg.YOLO.STRIDES)
self.classes = utils.read_class_names(cfg.YOLO.CLASSES)
self.num_classes = len(self.classes)
self.anchors = np.array(utils.get_anchors())
self.anchor_per_scale = cfg.YOLO.ANCHOR_PER_SCALE
self.max_bbox_per_scale = 150
self.img_id_list = self.load_car_person_list('train') if dataset_type == 'train' \
else self.load_car_person_list('test')
# print("self.img_id_list: ", self.img_id_list)
self.train_input_size = 416
self.annotations = self.load_annotations()
self.num_samples = len(self.img_id_list)
self.num_batchs = int(np.ceil(self.num_samples / self.batch_size))
self.batch_count = 0
def __init__(self):
self.input_size = 416
self.anchor_per_scale = 3
self.path1 = r"./data/classes/antenna.names" #修改
self.classes = utils.read_class_names(self.path1)
self.num_classes = len(self.classes)
self.score_threshold = 0.4
self.iou_threshold = 0.5
self.path3 = "./data/dataset/antenna_train.txt"
self.annotation_path = self.path3
self.write_image = True
self.path5 = r"./data/detection1/"
self.write_image_path = self.path5 # 是否将图片的预测结果保存
self.show_label = True
def get_mAP(Yolo,
dataset,
score_threshold=0.25,
iou_threshold=0.50,
TEST_INPUT_SIZE=TEST_INPUT_SIZE):
MINOVERLAP = 0.5 # default value (defined in the PASCAL VOC2012 challenge)
NUM_CLASS = read_class_names(TRAIN_CLASSES)
ground_truth_dir_path = 'mAP/ground-truth'
if os.path.exists(ground_truth_dir_path):
shutil.rmtree(ground_truth_dir_path)
if not os.path.exists('mAP'): os.mkdir('mAP')
os.mkdir(ground_truth_dir_path)
print(f'\ncalculating mAP{int(iou_threshold*100)}...\n')
gt_counter_per_class = {}
for index in range(dataset.num_samples):
ann_dataset = dataset.annotations[index]
original_image, bbox_data_gt = dataset.parse_annotation(
ann_dataset, True)
if len(bbox_data_gt) == 0:
bboxes_gt = []
classes_gt = []
else:
bboxes_gt, classes_gt = bbox_data_gt[:, :4], bbox_data_gt[:, 4]
ground_truth_path = os.path.join(ground_truth_dir_path,
str(index) + '.txt')
num_bbox_gt = len(bboxes_gt)
bounding_boxes = []
for i in range(num_bbox_gt):
class_name = NUM_CLASS[classes_gt[i]]
xmin, ymin, xmax, ymax = list(map(str, bboxes_gt[i]))
bbox = xmin + " " + ymin + " " + xmax + " " + ymax
bounding_boxes.append({
"class_name": class_name,
"bbox": bbox,
"used": False
})
# count that object
if class_name in gt_counter_per_class:
gt_counter_per_class[class_name] += 1
else:
# if class didn't exist yet
gt_counter_per_class[class_name] = 1
bbox_mess = ' '.join([class_name, xmin, ymin, xmax, ymax]) + '\n'
with open(f'{ground_truth_dir_path}/{str(index)}_ground_truth.json',
'w') as outfile:
json.dump(bounding_boxes, outfile)
gt_classes = list(gt_counter_per_class.keys())
# sort the classes alphabetically
gt_classes = sorted(gt_classes)
n_classes = len(gt_classes)
times = []
json_pred = [[] for i in range(n_classes)]
for index in range(dataset.num_samples):
ann_dataset = dataset.annotations[index]
image_name = ann_dataset[0].split('/')[-1]
original_image, bbox_data_gt = dataset.parse_annotation(
ann_dataset, True)
image = image_preprocess(np.copy(original_image),
[TEST_INPUT_SIZE, TEST_INPUT_SIZE])
image_data = image[np.newaxis, ...].astype(np.float32)
t1 = time.time()
if YOLO_FRAMEWORK == "tf":
pred_bbox = Yolo.predict(image_data)
elif YOLO_FRAMEWORK == "trt":
batched_input = tf.constant(image_data)
result = Yolo(batched_input)
pred_bbox = []
for key, value in result.items():
value = value.numpy()
pred_bbox.append(value)
t2 = time.time()
times.append(t2 - t1)
pred_bbox = [tf.reshape(x, (-1, tf.shape(x)[-1])) for x in pred_bbox]
pred_bbox = tf.concat(pred_bbox, axis=0)
bboxes = postprocess_boxes(pred_bbox, original_image, TEST_INPUT_SIZE,
score_threshold)
bboxes = nms(bboxes, iou_threshold, method='nms')
for bbox in bboxes:
coor = np.array(bbox[:4], dtype=np.int32)
score = bbox[4]
class_ind = int(bbox[5])
class_name = NUM_CLASS[class_ind]
score = '%.4f' % score
xmin, ymin, xmax, ymax = list(map(str, coor))
bbox = xmin + " " + ymin + " " + xmax + " " + ymax
json_pred[gt_classes.index(class_name)].append({
"confidence":
str(score),
"file_id":
str(index),
"bbox":
str(bbox)
})
ms = sum(times) / len(times) * 1000
fps = 1000 / ms
for class_name in gt_classes:
json_pred[gt_classes.index(class_name)].sort(
key=lambda x: float(x['confidence']), reverse=True)
with open(f'{ground_truth_dir_path}/{class_name}_predictions.json',
'w') as outfile:
json.dump(json_pred[gt_classes.index(class_name)], outfile)
# Calculate the AP for each class
sum_AP = 0.0
ap_dictionary = {}
# open file to store the results
with open("mAP/results.txt", 'w') as results_file:
results_file.write("# AP and precision/recall per class\n")
count_true_positives = {}
for class_index, class_name in enumerate(gt_classes):
count_true_positives[class_name] = 0
# Load predictions of that class
predictions_file = f'{ground_truth_dir_path}/{class_name}_predictions.json'
predictions_data = json.load(open(predictions_file))
# Assign predictions to ground truth objects
nd = len(predictions_data)
tp = [0] * nd # creates an array of zeros of size nd
fp = [0] * nd
for idx, prediction in enumerate(predictions_data):
file_id = prediction["file_id"]
# assign prediction to ground truth object if any
# open ground-truth with that file_id
gt_file = f'{ground_truth_dir_path}/{str(file_id)}_ground_truth.json'
ground_truth_data = json.load(open(gt_file))
ovmax = -1
gt_match = -1
# load prediction bounding-box
bb = [float(x) for x in prediction["bbox"].split()
] # bounding box of prediction
for obj in ground_truth_data:
# look for a class_name match
if obj["class_name"] == class_name:
bbgt = [float(x) for x in obj["bbox"].split()
] # bounding box of ground truth
bi = [
max(bb[0], bbgt[0]),
max(bb[1], bbgt[1]),
min(bb[2], bbgt[2]),
min(bb[3], bbgt[3])
]
iw = bi[2] - bi[0] + 1
ih = bi[3] - bi[1] + 1
if iw > 0 and ih > 0:
# compute overlap (IoU) = area of intersection / area of union
ua = (bb[2] - bb[0] + 1) * (bb[3] - bb[1] + 1) + (
bbgt[2] - bbgt[0] + 1) * (bbgt[3] - bbgt[1] +
1) - iw * ih
ov = iw * ih / ua
if ov > ovmax:
ovmax = ov
gt_match = obj
# assign prediction as true positive/don't care/false positive
if ovmax >= MINOVERLAP: # if ovmax > minimum overlap
if not bool(gt_match["used"]):
# true positive
tp[idx] = 1
gt_match["used"] = True
count_true_positives[class_name] += 1
# update the ".json" file
with open(gt_file, 'w') as f:
f.write(json.dumps(ground_truth_data))
else:
# false positive (multiple detection)
fp[idx] = 1
else:
# false positive
fp[idx] = 1
# compute precision/recall
cumsum = 0
for idx, val in enumerate(fp):
fp[idx] += cumsum
cumsum += val
cumsum = 0
for idx, val in enumerate(tp):
tp[idx] += cumsum
cumsum += val
#print(tp)
rec = tp[:]
for idx, val in enumerate(tp):
rec[idx] = float(tp[idx]) / gt_counter_per_class[class_name]
#print(rec)
prec = tp[:]
for idx, val in enumerate(tp):
prec[idx] = float(tp[idx]) / (fp[idx] + tp[idx])
#print(prec)
ap, mrec, mprec = voc_ap(rec, prec)
sum_AP += ap
text = "{0:.3f}%".format(
ap * 100
) + " = " + class_name + " AP " #class_name + " AP = {0:.2f}%".format(ap*100)
rounded_prec = ['%.3f' % elem for elem in prec]
rounded_rec = ['%.3f' % elem for elem in rec]
# Write to results.txt
results_file.write(text + "\n Precision: " + str(rounded_prec) +
"\n Recall :" + str(rounded_rec) + "\n\n")
print(text)
ap_dictionary[class_name] = ap
results_file.write("\n# mAP of all classes\n")
mAP = sum_AP / n_classes
text = "mAP = {:.3f}%, {:.2f} FPS".format(mAP * 100, fps)
results_file.write(text + "\n")
print(text)
return mAP * 100
if not os.path.isfile(output_directory + 'filter_influence' +
infl_version_text + '.npy'):
# Use when there is no info about Influence
influence_df = pd.DataFrame(data=[filter_num]).T
influence_df.columns = ['Filter']
influence_txt = '_without_influence'
else:
# Use when there is info about Influence
influence_txt = '_with_celltype_influence'
influence = np.load(output_directory + 'filter_influence' +
infl_version_text + '.npy')
influence_cellwise = np.load(output_directory +
'filter_cellwise_influence' +
infl_celltype_version_text +
infl_version_text + '.npy')
cell_names = utils.read_class_names(
'../data/' + species + '_Data/cell_type_names.txt', species)
influence_df = pd.DataFrame(data=influence_cellwise, columns=cell_names)
influence_df.insert(loc=0,
column='Influence',
value=pd.to_numeric(influence))
influence_df.insert(loc=0, column='Filter', value=filter_num)
# Activation stats for OCRs
num_seqs = np.loadtxt(output_directory + 'nseqs_per_filters.txt')
influence_df['num_seqs'] = num_seqs
activated_OCRs = np.load(output_directory + 'activated_OCRs.npy')
Ave_OCR_activity = np.mean(activated_OCRs, axis=1)
influence_df['Ave_OCR_activity'] = Ave_OCR_activity
Num_Act_OCRs = np.load(output_directory + 'n_activated_OCRs.npy')
def post_processor(bbox_q, cameras, out_q, frames, times, image_q = None):
classes = utils.read_class_names("./config/coco.names")
start_time = time.time()
start_time = time.strftime('%Y-%m-%d %H-%M-%S', time.localtime(start_time))
f_directory = cameras[0]["output"].split("/")[:-1]
f_directory.append("{}_output_frames".format(start_time))
f_directory = "/".join(f_directory)
os.mkdir(f_directory)
frames_processed = np.zeros(len(cameras))
try:
while True:
if not bbox_q.empty():
box_ind = bbox_q.get()
ped_bboxes = box_ind[0]
veh_bboxes = box_ind[1]
i = int(box_ind[2])
frame = box_ind[3]
# first, try and show frame
#frame = frame.transpose(1, 2, 0)
# cv2.imshow("test",frame)
# cv2.waitKey(0)
camera = cameras[i]
filename = camera["output"].format(start_time)
cam_name = camera["name"]
pix_real = camera["im-gps"]
frame_save = camera["save_frames"]
dt = times[i]
#find ft pts and convert to real_world
ped_pts = utils.get_ftpts(ped_bboxes)
realpts = tform.transform_pt_array(ped_pts, pix_real)
# verifies there is more than one point in the list (each point has size 2)]
if realpts.size > 2:
mytree = scipy.spatial.cKDTree(realpts)
errors = utils.compliance_count(mytree, realpts)
#FIXME can probably do these both in 1 function
avg_dist = utils.find_dist(mytree, realpts)
avg_min_dist = utils.find_min_dist(mytree, realpts)
else:
errors = 0
avg_min_dist = None
avg_dist = None
occupants = len(ped_bboxes)
#output info to csv file
with open(filename, 'a', newline='') as base_f:
writer = csv.writer(base_f)
utils.video_write_info(writer, realpts, str(dt), errors, occupants, avg_dist, avg_min_dist,cam_name)
stats = [i, errors, occupants, avg_min_dist]
#put outpt data into queue so it is accessible by the analyzer
if out_q.full():
temp = out_q.get()
out_q.put(stats)
if frame_save:
result = prep_frame(ped_pts, frame, camera, errors, occupants, ped_bboxes,veh_bboxes,classes)
#save frames
if frame_save:
frame_name = "{}/{}_{}_processed.jpg".format(f_directory,cam_name,int(frames_processed[i]))
cv2.imwrite(frame_name,result*255)
# if frame_show:
# if image_q.full():
# image_q.get()
# image_q.put(result)
# # FIXME - just for debugging, show frame on screen
# show_frame(result, i)
# if cv2.waitKey(1) & 0xFF == ord('q'): break
frames_processed[i] += 1
except:
print("Unexpected postprocessing error:", sys.exc_info()[0])
cv2.destroyAllWindows()
return
def main(type="image"):
model = Model()
names = utils.read_class_names("./data/classes.names")
end = time.time()
print(f"Execution time {end - start}")
if type == "video" or type == "camera":
if type == "video":
vid = cv2.VideoCapture(input_video_file)
elif type == "camera":
vid = cv2.VideoCapture(0)
frame_width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
frame_per_second = int(vid.get(cv2.CAP_PROP_FPS))
codec = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter(output_video_file, codec, frame_per_second,
(frame_width, frame_height))
while True:
_, image = vid.read()
if image is None:
logging.warning("Empty Frame")
time.sleep(0.1)
continue
image_size = image.shape[:2]
image_input = tf.expand_dims(image, 0)
image_input = utils.transform_images(image_input, 416)
predicted_bounding_box = model.predict(image_input)
predicted_bounding_box = [
tf.reshape(x, (-1, tf.shape(x)[-1]))
for x in predicted_bounding_box
]
predicted_bounding_box = tf.concat(predicted_bounding_box, axis=0)
final_detected_boxes, class_names, scores = utils.box_detector(
predicted_bounding_box)
image = utils.get_human_box_detection(final_detected_boxes,
class_names, scores, names,
image)
if output_video_file:
out.write(image)
image = cv2.resize(image, (1200, 700))
cv2.imshow('output', image)
if cv2.waitKey(1) == ord('q'):
break
cv2.destroyAllWindows()
if type == "image":
for i, image_file in enumerate(input_image_files):
image = cv2.imread(image_file)
image_input = tf.expand_dims(image, 0)
image_input = utils.transform_images(image_input, 416)
predicted_bounding_boxes = model.predict(image_input)
predicted_bounding_box = [
tf.reshape(x, (-1, tf.shape(x)[-1]))
for x in predicted_bounding_boxes
]
predicted_bounding_box = tf.concat(predicted_bounding_box, axis=0)
final_detected_boxes, class_names, scores = utils.box_detector(
predicted_bounding_box)
image = utils.get_human_box_detection(final_detected_boxes,
class_names, scores, names,
image)
image = cv2.resize(image, (1200, 700))
cv2.imwrite("output_%d.jpg" % i, image)
cv2.imshow('output7', image)
if cv2.waitKey(0) == ord('q'):
cv2.destroyAllWindows()
def proc_video(ind, i_lock, frames, times, bbox_q, cameras, gpu):
classes = utils.read_class_names("./config/coco.names")
worker = Worker(gpu)
while(True):
if worker.avail:
worker.mark_unavail()
# save current index so it doesn't change while processing
#lock ensures that multiple processes aren't working on same frame
try:
with i_lock:
i = ind.value
ind.value = ind.value + 1
ind.value = ind.value % len(frames)
except:
worker.mark_avail()
continue
#loop through frames, find people, record occupants and infractions
camera = cameras[i]
try:
worker.set_frame(np.asarray(frames[i]))
except ValueError:
worker.mark_avail()
torch.cuda.empty_cache()
continue
ped_bboxes,veh_bboxes,blur = worker.get_bboxes()
# denormalize
im = F.normalize(worker.gpu_frame[0],mean = [-0.485/0.229, -0.456/0.224, -0.406/0.225],
std = [1/0.229, 1/0.224, 1/0.225])
im = F.to_pil_image(im.cpu())
open_cv_image = np.array(im)
im = open_cv_image.copy()/255.0
#im = im[:,:,::-1]
# blur all peds regardless of confidence
for ped in blur:
im = utils.find_blur_face(ped.int(),im)
# parse metrics and write output frame
filename = camera["output"]
cam_name = camera["name"]
pix_real = camera["im-gps"]
frame_save = camera["save_frames"]
dt = times[i]
#find ft pts and convert to real_world
ped_pts = utils.get_ftpts(ped_bboxes)
realpts = tform.transform_pt_array(ped_pts, pix_real)
# also convert veh points to realworld
real_veh_pts = tform.transform_pt_array(utils.get_ftpts(veh_bboxes),pix_real)
# verifies there is more than one point in the list (each point has size 2)]
if realpts.size > 2:
mytree = scipy.spatial.cKDTree(realpts)
errors = utils.compliance_count(mytree, realpts)
#FIXME can probably do these both in 1 function
avg_dist = utils.find_dist(mytree, realpts)
avg_min_dist = utils.find_min_dist(mytree, realpts)
else:
errors = 0
avg_min_dist = None
avg_dist = None
occupants = len(ped_bboxes)
#save frames with occupants
if frame_save and (occupants > 12 or errors > 5):
result = prep_frame(ped_pts, im, camera, errors, occupants, ped_bboxes,veh_bboxes,classes)
dt_fixed = str(dt).replace(":","-").split(".")[0]
frame_name = "{}/{}.jpg".format(camera["frame_dir"],dt_fixed)
cv2.imwrite(frame_name,result*255)
#combine so bounding boxes remain associated with camera
output = [realpts,real_veh_pts,dt,errors,occupants,avg_dist,avg_min_dist,cam_name,i,worker.id]
bbox_q.put(output)
worker.count += 1
worker.mark_avail()
return
def main(errs, ocpts, dists, updated, frames, times, avgs, avg_lock, i_lock,
ind, out_q, bbox_q, image_q, config, ctx):
# file containing camera information
# transform_f = 'C:/Users/Nikki/Documents/work/inputs-outputs/transforms.csv'
# transform_f = 'C:/Users/Nikki/Documents/work/inputs-outputs/test.csv'
# transform_f = 'C:/Users/Nikki/Documents/work/inputs-outputs/test_all.csv'
# transform_f = './config/LAMBDA_TEST.config'
#create VidObjs to store information about each camera
cameras = initialize_cams(config)
num_cams = len(cameras)
#length of queues, kinda arbitrary - this is the number that will be used for moving avg analytics
buf_num = 3
#need to fix these references
# errs = var_list[0]
# ocpts = var_list[1]
# dists = var_list[2]
# updated = var_list[3]
# frames = var_list[4]
# times = var_list[5]
# avgs = var_list[6]
# avg_lock = var_list[7]
# i_lock = var_list[8]
# ind = var_list[9]
# bbox_q = var_list[10]
# ind = var_list[11]
#uncomment if running from this file
# manager = mp.Manager()
# print('MP manager created')
# # create manager to handle shared variables across processes
# updated = manager.Value(c_bool, False)
# frames = manager.list([None]* num_cams)
# times = manager.list([None]* num_cams)
# avgs = manager.list([None] * 5)
# avg_lock = manager.Lock()
# i_lock = manager.Lock()
# out_q = manager.Queue(num_cams*2)
# bbox_q = manager.Queue()
# ind = manager.Value(int, 0)
# image_q = manager.Queue(num_cams*2)
# # sample = manager.list([None] * 5)
# errs = manager.list()
# ocpts = manager.list()
# dists = manager.list()
# s_lock = manager.Lock()
# # for _ in range(num_cams):
# # ocpts.append( [None]* buf_num)
# for i in range(num_cams):
# errs.append(manager.list([None]))
# ocpts.append(manager.list([None]))
# dists.append(manager.list([None]))
classes = utils.read_class_names("./config/coco.names")
#stores frame data that has been transfered to GPU
GPU_LIST = [i for i in range(torch.cuda.device_count())]
# workers = setup_gpus(vids, gpu_list = GPU_LIST)
#start model
# model = detector.start_model()
streamers = []
worker = Worker(2)
frame = cv2.imread("/home/worklab/Desktop/test1.png")
worker.set_frame(frame)
ped, veh = worker.get_bboxes()
cameras[0]["frame_size"] = (worker.gpu_frame[0].shape[:2])
im = F.normalize(worker.gpu_frame[0],
mean=[-0.485 / 0.229, -0.456 / 0.224, -0.406 / 0.225],
std=[1 / 0.229, 1 / 0.224, 1 / 0.225])
im = F.to_pil_image(im.cpu())
open_cv_image = np.array(im)
im = open_cv_image.copy() / 255.0
im = im[:, :, ::-1]
#combine so bounding boxes remain associated with camera
i = 0
box_ind = (ped, veh, i, im)
ped_bboxes = box_ind[0]
veh_bboxes = box_ind[1]
i = box_ind[2]
frame = box_ind[3]
# first, try and show frame
#frame = frame.transpose(1, 2, 0)
# cv2.imshow("test",frame)
# cv2.waitKey(0)
camera = cameras[i]
filename = camera["address"]
pix_real = camera["im-gps"]
frame_show = camera["save_frames"]
dt = times[i]
#find ft pts and convert to real_world
ped_pts = utils.get_ftpts(ped_bboxes)
realpts = tform.transform_pt_array(ped_pts, pix_real)
# verifies there is more than one point in the list (each point has size 2)]
if realpts.size > 2:
mytree = scipy.spatial.cKDTree(realpts)
errors = utils.compliance_count(mytree, realpts)
#FIXME can probably do these both in 1 function
avg_dist = utils.find_dist(mytree, realpts)
avg_min_dist = utils.find_min_dist(mytree, realpts)
else:
errors = 0
avg_min_dist = None
avg_dist = None
occupants = len(ped_bboxes)
#output info to csv file
with open(filename, 'a', newline='') as base_f:
writer = csv.writer(base_f)
utils.video_write_info(writer, realpts, str(dt), errors, occupants,
avg_dist, avg_min_dist)
stats = [i, errors, occupants, avg_min_dist]
#put outpt data into queue so it is accessible by the analyzer
if out_q.full():
out_q.get()
out_q.put(stats)
result = prep_frame(ped_pts, frame, camera, errors, occupants, ped_bboxes,
veh_bboxes, classes)
cv2.imshow("frame", result)
cv2.waitKey(0)
def valid_NB(datafile, cfgfile, weightfile, epoch, prefix='result'):
model = Darknet(cfgfile)
options = read_data_file(datafile)
data_root = options['valid']
class_root = options['names']
names = read_class_names(class_root)
device = 'cuda' if torch.cuda.is_available() else 'cpu'
with open(data_root, 'r') as f:
lines = f.readlines()
valid_files = [item.strip() for item in lines]
model.load_weights(weightfile)
model = model.to(device)
model.eval()
NB_model = joblib.load('NB models/epoch_{}.pkl'.format(int(epoch)))
data = YoloDataset(data_root,
shape=(model.width, model.height),
transform=transforms.Compose([transforms.ToTensor()]),
train=False)
batch_size = 2
kwargs = {'num_workers': 4, 'pin_memory': True}
data_loader = DataLoader(data,
batch_size=batch_size,
shuffle=False,
**kwargs)
fs = [None] * model.num_classes
if not os.path.exists(prefix):
os.makedirs(prefix)
for i in range(model.num_classes):
filename = prefix + '/' + str(names[i]) + '.txt'
fs[i] = open(filename, 'w')
net_shape = (model.width, model.height)
conf_thresh = 0.005
nms_thresh = 0.45
fileIndex = 0
for index, (imgs, labels, org_w, org_h) in enumerate(data_loader):
imgs = imgs.to(device)
output = model(imgs)
batch_boxes = get_all_boxes(output,
net_shape,
conf_thresh,
model.num_classes,
device,
validation=True)
for i in range(len(batch_boxes)):
fileId = os.path.basename(valid_files[fileIndex]).split('.')[
0] # gei naive image name without suffix
w, h = float(org_w[i]), float(org_h[i])
# print(valid_files[fileIndex], '{}/{}'.format(fileIndex+1, len(data_loader) * batch_size))
fileIndex += 1
boxes = batch_boxes[i]
correct_yolo_boxes(boxes, w, h, model.width, model.height)
boxes = auto_thresh_nms(boxes, NB_model)
for box in boxes:
x1 = (box[0] - box[2] / 2.0) * w
y1 = (box[1] - box[3] / 2.0) * h
x2 = (box[0] + box[2] / 2.0) * w
y2 = (box[1] + box[3] / 2.0) * h
# 包含物体的概率，乘以每一类的概率
det_conf = box[4]
for j in range((len(box) - 5) // 2):
cls_conf = box[5 + 2 * j]
cls_id = int(box[5 + 2 * j + 1])
prob = det_conf * cls_conf
fs[cls_id].write('{:s} {:f} {:f} {:f} {:f} {:f}\n'.format(
fileId, prob, x1, y1, x2, y2))
for i in range(len(fs)):
fs[i].close()
def __init__(self):
print("initialize values...")
self.anchor_per_scale = cfg.YOLO.ANCHOR_PER_SCALE
self.classes = utils.read_class_names(cfg.YOLO.CLASSES)
self.num_classes = len(self.classes)
self.learn_rate_init = cfg.TRAIN.LEARN_RATE_INIT
self.learn_rate_end = cfg.TRAIN.LEARN_RATE_END
self.first_stage_epochs = cfg.TRAIN.FISRT_STAGE_EPOCHS
self.second_stage_epochs = cfg.TRAIN.SECOND_STAGE_EPOCHS
self.epoch = cfg.TRAIN.EPOCH
self.warmup_periods = cfg.TRAIN.WARMUP_EPOCHS
# self.initial_weight = cfg.TRAIN.INITIAL_WEIGHT
self.time = time.strftime('%Y-%m-%d-%H-%M-%S', time.localtime(time.time()))
self.moving_ave_decay = cfg.YOLO.MOVING_AVE_DECAY
self.max_bbox_per_scale = cfg.YOLO.MAX_OUTPUT_SIZE
self.train_logdir = "./train_log/"
self.trainset = Dataset('train')
self.testset = Dataset('test')
self.steps_per_period = len(self.trainset)
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
self.sess = tf.Session(config=config)
with tf.name_scope('define_input'):
print("defining inpuuts...")
self.input_data = tf.placeholder(dtype=tf.float32, shape=[cfg.TRAIN.BATCH_SIZE, self.trainset.train_input_size,
self.trainset.train_input_size, 3],
name='input_data')
self.label_sbbox = tf.placeholder(dtype=tf.float32, name='label_sbbox')
self.label_mbbox = tf.placeholder(dtype=tf.float32, name='label_mbbox')
self.label_lbbox = tf.placeholder(dtype=tf.float32, name='label_lbbox')
self.true_sbbox = tf.placeholder(dtype=tf.float32, name='true_sbbox')
self.true_mbbox = tf.placeholder(dtype=tf.float32, name='true_mbbox')
self.true_lbbox = tf.placeholder(dtype=tf.float32, name='true_lbbox')
self.trainable = tf.placeholder(dtype=tf.bool, name='trainig')
with tf.name_scope('define_loss'):
print("defining loss...")
self.model = YoloV3(inputs=self.input_data, training=self.trainable)
self.network_para = tf.global_variables()
self.giou_loss, self.conf_loss, self.prob_loss, self.debug = \
self.model.compute_loss(self.label_sbbox, self.label_mbbox, self.label_lbbox, self.true_sbbox,
self.true_mbbox, self.true_lbbox)
# print("self.giou_loss: ", self.giou_loss, " self.conf_loss: ", self.conf_loss, " self.prob_loss: ", self.prob_loss)
# self.loss = self.giou_loss + self.conf_loss + self.prob_loss
new_giou_loss = self.debug[4] + self.debug[9] + self.debug[14]
self.loss = new_giou_loss + self.conf_loss + self.prob_loss
# TODO: change this part if training doesnt do good
with tf.name_scope('define_learning_rate'):
print("defining learning rate...")
self.learning_rate = cfg.TRAIN.LEARN_RATE_INIT
with tf.name_scope('learn_rate'):
print("learn_rate")
self.global_step = tf.Variable(1.0, dtype=tf.float64, trainable=False, name='global_step')
warmup_steps = tf.constant(self.warmup_periods * 1,
dtype=tf.float64, name='warmup_steps')
train_steps = tf.constant(self.epoch * self.steps_per_period,
dtype=tf.float64, name='train_steps')
self.learn_rate = tf.cond(
pred=self.global_step < warmup_steps,
true_fn=lambda: self.global_step / warmup_steps * self.learn_rate_init,
false_fn=lambda: self.learn_rate_end + 0.5 * (self.learn_rate_init - self.learn_rate_end) *
(1 + tf.cos(
(self.global_step - warmup_steps) / (train_steps - warmup_steps) * np.pi))
)
global_step_update = tf.assign_add(self.global_step, 1.0)
# TODO: change this part if training doesnt do good
with tf.name_scope("define_weight_decay"):
print("defining weight decay...")
moving_ave = tf.train.ExponentialMovingAverage(self.moving_ave_decay).apply(tf.trainable_variables())
with tf.name_scope('summary'):
print("summary...")
tf.summary.scalar("giou_loss", self.giou_loss)
tf.summary.scalar("conf_loss", self.conf_loss)
tf.summary.scalar("prob_loss", self.prob_loss)
tf.summary.scalar("total_loss", self.loss)
if os.path.exists(self.train_logdir):
print('pass')
else:
os.mkdir(self.train_logdir)
self.write_op = tf.summary.merge_all()
self.summary_writer = tf.summary.FileWriter(self.train_logdir, graph=self.sess.graph)
with tf.name_scope('define_train'):
print("defining train...")
trainable_var_list = tf.trainable_variables()
optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(self.loss,
var_list=trainable_var_list) # the training step
# optimizer = tf.train.GradientDescentOptimizer(learning_rate=self.learning_rate).minimize(self.loss,
# var_list=trainable_var_list)
# optimizer = tf.train.MomentumOptimizer(learning_rate=self.learn_rate, momentum=0.9).minimize(self.loss,
# var_list=trainable_var_list)
with tf.control_dependencies(
tf.get_collection(tf.GraphKeys.UPDATE_OPS)): # normalize batch from the last round
with tf.control_dependencies([optimizer, global_step_update]):
with tf.control_dependencies([moving_ave]): # decay
self.train_op_with_all_variables = tf.no_op()
with tf.name_scope('loader_and_saver'):
print("defining loader and saver...")
self.loader = tf.train.Saver(self.network_para)
self.saver = tf.train.Saver(tf.global_variables(), max_to_keep=10)
def __init__(self, inputs, training, data_format=None):
"""Creates the model.
Args:
n_classes: Number of class labels.
model_size: The input size of the model.
max_output_size: Max number of boxes to be selected for each class.
iou_threshold: Threshold for the IOU.
confidence_threshold: Threshold for the confidence score.
data_format: The input format.
Returns:
None.
"""
self.iou_loss_thresh = 0.5
self.num_class = 2
self.anchor_per_scale = 3
self.classes = utils.read_class_names(cfg.YOLO.CLASSES)
self.n_classes = len(self.classes)
self.model_size = cfg.YOLO.MODEL_SIZE
self.max_output_size = cfg.YOLO.MAX_OUTPUT_SIZE
self.iou_threshold = cfg.YOLO.IOU_THRESHOLD
self.data_format = data_format
self.strides = np.array(cfg.YOLO.STRIDES)
self._giou_loss_backup = None
if self.data_format == 'channels_first':
inputs = tf.transpose(inputs, [0, 3, 1, 2])
with tf.variable_scope('yolo_v3_model'):
self.anchors = utils.get_anchors()
route1, route2, inputs = darknet53(inputs=inputs, training=training, data_format=self.data_format)
route, inputs = yolo_conv_block(inputs=inputs, filters=512, training=training, data_format=self.data_format,
name='yolo_conv_block_1')
self.conv_lbbox = yolo_detection_layer(inputs, n_classes=self.n_classes,
anchors=self.anchors[2],
img_size=self.model_size,
data_format=self.data_format,
name='con_lbbox_layer',
strides=self.strides[2])
inputs = con2d_fixed_padding(route, filters=256, kernel_size=1, data_format=self.data_format, name='conv_lbbox')
inputs = batch_norm(inputs, training=training, data_format=self.data_format)
inputs = tf.nn.leaky_relu(inputs, alpha=cfg.YOLO.LEAKY_RELU)
upsample_output_size = route2.get_shape().as_list()
inputs = upsample(inputs, out_shape=upsample_output_size, data_format=self.data_format)
# get the channel axis
axis = 1 if self.data_format == 'channels_first' else 3
inputs = tf.concat((inputs, route2), axis=axis)
route, inputs = yolo_conv_block(inputs, filters=256, training=training, data_format=self.data_format,
name='yolo_conv_block_2')
self.conv_mbbox = yolo_detection_layer(inputs, n_classes=self.n_classes,
anchors=self.anchors[1],
img_size=self.model_size,
data_format=self.data_format,
name='con_mbbox_layer',
strides=self.strides[1])
inputs = con2d_fixed_padding(route, filters=128, kernel_size=1, data_format=self.data_format, name='conv_mbbox')
inputs = batch_norm(inputs, training=training, data_format=self.data_format)
inputs = tf.nn.leaky_relu(inputs, alpha=cfg.YOLO.LEAKY_RELU)
upsample_output_size = route1.get_shape().as_list()
inputs = upsample(inputs, out_shape=upsample_output_size, data_format=self.data_format)
inputs = tf.concat((inputs, route1), axis=axis)
route, inputs = yolo_conv_block(inputs, filters=128, training=training, data_format=self.data_format,
name='yolo_conv_block_3')
self.conv_sbbox = yolo_detection_layer(inputs, n_classes=self.n_classes,
anchors=self.anchors[0],
img_size=self.model_size,
data_format=self.data_format,
name='conv_sbbox',
strides=self.strides[0])
with tf.variable_scope('pred_sbbox'):
self.pred_sbbox = self.decode(self.conv_sbbox, self.anchors[0], self.strides[0])
print("self.pred_sbbox: ", self.pred_sbbox.shape)
with tf.variable_scope('pred_mbbox'):
self.pred_mbbox = self.decode(self.conv_mbbox, self.anchors[1], self.strides[1])
with tf.variable_scope('pred_lbbox'):
self.pred_lbbox = self.decode(self.conv_lbbox, self.anchors[2], self.strides[2])
def post_processor(bbox_q, cameras, out_q, frames, times, image_q=None):
classes = utils.read_class_names("./config/coco.names")
try:
while True:
if not bbox_q.empty():
box_ind = bbox_q.get()
ped_bboxes = box_ind[0]
veh_bboxes = box_ind[1]
i = box_ind[2]
frame = box_ind[3]
# first, try and show frame
#frame = frame.transpose(1, 2, 0)
# cv2.imshow("test",frame)
# cv2.waitKey(0)
camera = cameras[i]
filename = camera["address"]
pix_real = camera["im-gps"]
frame_show = camera["save_frames"]
dt = times[i]
#find ft pts and convert to real_world
ped_pts = utils.get_ftpts(ped_bboxes)
realpts = tform.transform_pt_array(ped_pts, pix_real)
# verifies there is more than one point in the list (each point has size 2)]
if realpts.size > 2:
mytree = scipy.spatial.cKDTree(realpts)
errors = utils.compliance_count(mytree, realpts)
#FIXME can probably do these both in 1 function
avg_dist = utils.find_dist(mytree, realpts)
avg_min_dist = utils.find_min_dist(mytree, realpts)
else:
errors = 0
avg_min_dist = None
avg_dist = None
occupants = len(ped_bboxes)
#output info to csv file
with open(filename, 'a', newline='') as base_f:
writer = csv.writer(base_f)
utils.video_write_info(writer, realpts, str(dt), errors,
occupants, avg_dist, avg_min_dist)
stats = [i, errors, occupants, avg_min_dist]
#put outpt data into queue so it is accessible by the analyzer
if out_q.full():
out_q.get()
out_q.put(stats)
result = prep_frame(ped_pts, frame, camera, errors, occupants,
ped_bboxes, veh_bboxes, classes)
cv2.imshow("frame", result)
cv2.waitKey(0)
# if frame_save or frame_show:
# result = prep_frame(ftpts, frame, vid, errors, occupants, bboxes)
### UNCOMMENT AND USE
# frame_save = True
# #save frames
# if frame_save:
# outpt_frame(result, vid)
# if frame_show:
# if image_q.full():
# image_q.get()
# image_q.put(result)
# # FIXME - just for debugging, show frame on screen
show_frame(result, i)
if cv2.waitKey(1) & 0xFF == ord('q'): break
except KeyboardInterrupt:
print("Unexpected postprocessing error:", sys.exc_info()[0])
cv2.destroyAllWindows()
return
import tensorflow as tf
import numpy as np
from config import cfg
from utils import read_class_names, get_anchors
NUM_CLASS = len(read_class_names(cfg.YOLO.CLASSES))
ANCHORS = get_anchors(cfg.YOLO.ANCHORS)
STRIDES = np.array(cfg.YOLO.STRIDES)
def decode(conv_output, i=0):
"""
:return [batch_size, output_size, output_size, anchor_per_scale, 5 + num_classes]
box format: (x, y, w, h, score, probability)
"""
conv_shape = tf.shape(conv_output)
batch_size = conv_shape[0]
output_size = conv_shape[1]
conv_output = tf.reshape(
conv_output, (batch_size, output_size, output_size, 3, 5 + NUM_CLASS))
conv_raw_dxdy = conv_output[:, :, :, :, 0:2]
conv_raw_dwdh = conv_output[:, :, :, :, 2:4]
conv_raw_conf = conv_output[:, :, :, :, 4:5]
conv_raw_prob = conv_output[:, :, :, :, 5:]
y = tf.tile(
tf.range(output_size, dtype=tf.int32)[:, tf.newaxis], [1, output_size])
x = tf.tile(
def run_processing(video_stream: cv2.VideoCapture):
return_elements = [
"input/input_data:0", "pred_sbbox/concat_2:0", "pred_mbbox/concat_2:0",
"pred_lbbox/concat_2:0"
]
pb_file = "./model/model.pb"
num_classes = 80
input_size = 416
graph = tf.Graph()
return_tensors = utils.read_pb_return_tensors(graph, pb_file,
return_elements)
counter = 0
classes = utils.read_class_names()
with tf.Session(graph=graph) as sess:
while True:
return_value, frame = video_stream.read()
if return_value:
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
counter = 0
else:
counter += 1
if counter > 5:
return
else:
continue
preproc_time_start = time.time()
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()
preproc_time = prev_time - preproc_time_start
info = "preprocessing time: %.2f ms" % (1000 * preproc_time)
print(info)
model_time = time.time()
pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
[return_tensors[1], return_tensors[2], return_tensors[3]],
feed_dict={return_tensors[0]: image_data})
end_model_time = time.time()
proc_model_time = end_model_time - model_time
info = "preprocessing model time: %.2f ms" % (1000 *
proc_model_time)
print(info)
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))
],
axis=0)
bboxes = utils.postprocess_boxes(pred_bbox, frame_size, input_size,
0.7)
bboxes = utils.nms(bboxes, 0.45, method='nms')
result_image = utils.draw_bbox(frame, bboxes, classes)
curr_time = time.time()
exec_time = curr_time - prev_time
info = "time: %.2f ms" % (1000 * exec_time)
print(info)
cv2.namedWindow("result", cv2.WINDOW_AUTOSIZE)
result = cv2.cvtColor(result_image, cv2.COLOR_RGB2BGR)
cv2.imshow("result", result)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# File name : yolo3.py
# Description : Define yolo3 model,loss function,etc.
#
#=====================================================
import numpy as np
import tensorflow as tf
import utils
import common
import backbone
import getConfig
cfg = {}
cfg = getConfig.getConfig()
NUM_CLASS = len(utils.read_class_names(cfg['yolo_classes_names']))
ANCHORS = utils.get_anchors(cfg['yolo_anchors'])
STRIDES = np.array(cfg['yolo_strides'])
IOU_LOSS_THRESHOLD = cfg['yolo_iou_loss_threshold']
def yolo3(input_layer):
branch_1,branch_2,conv = backbone.backbone(input_layer)
conv = common.conv(conv,(1,512))
conv = common.conv(conv,(3,1024))
conv = common.conv(conv,(1,512))
conv = common.conv(conv,(3,1024))
conv = common.conv(conv,(1,512))
conv_l_branch = common.conv(conv,(3,1024))
l_output = common.conv(conv_l_branch,(1,3 * (NUM_CLASS + 5)),activation = False,bn = False)
