def main(_argv):
if FLAGS.tiny:
initial_model = YoloV3Tiny(
FLAGS.size,
#training=True,
classes=FLAGS.initial_num_classes)
anchors = yolo_tiny_anchors
anchor_masks = yolo_tiny_anchor_masks
new_custom_model = YoloV3Tiny(
FLAGS.size,
#training=True,
classes=FLAGS.custom_num_classes)
else:
initial_model = YoloV3(
FLAGS.size,
#training=True,
classes=FLAGS.initial_num_classes)
anchors = yolo_anchors
anchor_masks = yolo_anchor_masks
new_custom_model = YoloV3(
FLAGS.size,
#training=True,
classes=FLAGS.custom_num_classes)
load_weights_original(initial_model)
copy_darknet_weights_to_custom_model(initial_model, new_custom_model)
save_custom_model_weights(new_custom_model)
def load_model():
if FLAGS.tiny:
full_model = YoloV3Tiny(
FLAGS.size,
# training=True,
classes=FLAGS.num_classes)
training_model = YoloV3Tiny(FLAGS.size,
training=True,
classes=FLAGS.num_classes)
else:
full_model = YoloV3(
FLAGS.size,
# training=True,
classes=FLAGS.num_classes)
training_model = YoloV3(FLAGS.size,
training=True,
classes=FLAGS.num_classes)
if FLAGS.first_load:
training_model = load_weights_first(full_model, training_model)
return training_model
elif FLAGS.load_from_checkpoint:
checkpoint_path = "custom_initial_weights/yolov3.tf"
checkpoint_dir = os.path.dirname(checkpoint_path)
latest_train = tf.train.latest_checkpoint(checkpoint_dir)
training_model.load_weights(latest_train)
if FLAGS.transfer == 'fine_tune':
# freeze darknet
darknet = training_model.get_layer('yolo_darknet')
freeze_all(darknet)
return training_model
def main(_argv):
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
tf.saved_model.save(yolo, FLAGS.output)
logging.info("model saved to: {}".format(FLAGS.output))
model = tf.saved_model.load(FLAGS.output)
infer = model.signatures[tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY]
logging.info(infer.structured_outputs)
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
img = tf.image.decode_image(open(FLAGS.image, 'rb').read(), channels=3)
img = tf.expand_dims(img, 0)
img = transform_images(img, 416)
t1 = time.time()
outputs = infer(img)
boxes, scores, classes, nums = outputs["yolo_nms"], outputs[
"yolo_nms_1"], outputs["yolo_nms_2"], outputs["yolo_nms_3"]
t2 = time.time()
logging.info('time: {}'.format(t2 - t1))
logging.info('detections:')
for i in range(nums[0]):
logging.info('\t{}, {}, {}'.format(class_names[int(classes[0][i])],
scores[0][i].numpy(),
boxes[0][i].numpy()))
def main(args):
# 1、初始化模型并加载权重
if args.tiny:
yolo = YoloV3Tiny(classes=args.num_classes)
else:
yolo = YoloV3(classes=args.num_classes)
yolo.load_weights(args.weights)
logging.info('加载模型权重weights')
# 加载目标类型
class_names = [c.strip() for c in open(args.classes).readlines()]
# 2、加载图片处理图片并使用模型进行预测
img = tf.image.decode_image(open(args.image, 'rb').read(), channels=3)
img = tf.expand_dims(img, 0)
img = transform_images (img, args.size)
# 记录时间
t1 = time.time()
boxes, scores, classes, nums = yolo(img)
t2 = time.time()
logging.info('耗时: {}'.format(t2 - t1))
logging.info('检测结果:')
print(boxes, scores, classes, nums)
for i in range(nums[0]):
logging.info('\t{}, {}, {}'.format(class_names[int(classes[0][i])],
np.array(scores[0][i]),
np.array(boxes[0][i])))
# 3、显示图片并将图片框画出
img = cv2.imread(args.image)
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
cv2.imwrite(args.output, img)
logging.info('output saved to: {}'.format(args.output))
def init():
os.system('ls -la')
os.system('pwd')
os.system('ls azure -la')
os.system('cat main.py')
os.system('cat model_config_map.json')
global yolo, class_names, classes_path, weights_path, tiny, size, output_path, num_classes, physical_devices
# customize your API through the following parameters
classes_path = './azure/data/labels/coco.names'
weights_path = Model.get_model_path("yolov3-tf")
print("Model Path is ", weights_path)
tiny = False # set to True if using a Yolov3 Tiny model
size = 416 # size images are resized to for model
output_path = './azure/detections/' # path to output folder where images with detections are saved
num_classes = 80 # number of classes in model
# load in weights and classes
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
if tiny:
yolo = YoloV3Tiny(classes=num_classes)
else:
yolo = YoloV3(classes=num_classes)
yolo.load_weights(
'./azureml-models/yolov3-tf/4/tf/yolov3.tf').expect_partial()
print('weights loaded')
class_names = [c.strip() for c in open(classes_path).readlines()]
print('classes loaded')
def main(_argv):
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
img = tf.image.decode_image(open(FLAGS.image, 'rb').read(), channels=3)
img = tf.expand_dims(img, 0)
img = transform_images(img, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo(img)
t2 = time.time()
logging.info('time: {}'.format(t2 - t1))
logging.info('detections:')
for i in range(nums[0]):
logging.info('\t{}, {}, {}'.format(class_names[int(classes[0][i])],
np.array(scores[0][i]),
np.array(boxes[0][i])))
img = cv2.imread(FLAGS.image)
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
cv2.imwrite(FLAGS.output, img)
logging.info('output saved to: {}'.format(FLAGS.output))
def main(_argv):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights).expect_partial()
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
if FLAGS.tfrecord:
dataset = load_tfrecord_dataset(FLAGS.tfrecord, FLAGS.classes,
FLAGS.size)
dataset = dataset.shuffle(512)
img_raw, _label = next(iter(dataset.take(1)))
else:
img_raw = tf.image.decode_image(open(FLAGS.image, 'rb').read(),
channels=3)
img = tf.expand_dims(img_raw, 0)
img = transform_images(img, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo(img)
t2 = time.time()
img = cv2.cvtColor(img_raw.numpy(), cv2.COLOR_RGB2BGR)
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
cv2.imwrite(FLAGS.output, img)
def main(_argv):
if FLAGS.tiny:
yolo = YoloV3Tiny()
else:
yolo = YoloV3()
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
times = []
while True:
(rpiName, frame) = imageHub.recv_image()
imageHub.send_reply(b'OK')
img = imutils.resize(frame, width=416)
img_in = tf.expand_dims(img, 0)
img_in = transform_images(img_in, FLAGS.size)
boxes, scores, classes, nums = yolo.predict(img_in)
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
# img = cv2.putText(img, "Time: {:.2f}ms".format(sum(times)/len(times)*1000), (0, 30),
# cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 2)
cv2.imshow('output', img)
if cv2.waitKey(1) == ord('q'):
break
cv2.destroyAllWindows()
def main(_argv):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
for physical_device in physical_devices:
tf.config.experimental.set_memory_growth(physical_device, True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights).expect_partial()
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
print(FLAGS.output)
os.chdir(FLAGS.image)
for file in os.listdir(FLAGS.image):
if file.endswith(".jpg"):
logging.info("processing {}".format(file))
img_raw = tf.image.decode_image(open(file, 'rb').read(), channels=3)
img_predict(img_raw,yolo,class_names,file)
logging.info('output saved to: {}'.format(FLAGS.output))
def main(_argv):
if FLAGS.tiny:
yolo = YoloV3Tiny(FLAGS.input_size, classes=FLAGS.num_classes)
else:
yolo = YoloV3(FLAGS.input_size, classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights).expect_partial()
logging.info('weights loaded')
path = 'tmp/yolov3.h5'
out_path = 'tmp/yolov3.tflite'
if FLAGS.tiny:
path = 'tmp/yolov3-tiny.h5'
out_path = 'tmp/yolov3-tiny.tflite'
yolo.save(path)
logging.info(f'keras model saved to location {path}')
converter = tf.lite.TFLiteConverter.from_keras_model(yolo)
converter.target_spec.supported_ops = [
tf.lite.OpsSet.TFLITE_BUILTINS,
tf.lite.OpsSet.SELECT_TF_OPS
]
converter.experimental_new_converter = True
converter.experimental_new_quantizer = True
converter.allow_custom_ops = True
tflite_model = converter.convert()
logging.info(f'model converted')
open(out_path, 'wb').write(tflite_model)
logging.info(f'tflite model saved to location {out_path}')
def __init__(self):
# Definition of the parameters
self.max_cosine_distance = 0.5
self.nn_budget = None
self.nms_max_overlap = 1.0
#initialize deep sort
self.model_filename = 'model_data/mars-small128.pb'
self.encoder = gdet.create_box_encoder(self.model_filename,
batch_size=1)
self.metric = nn_matching.NearestNeighborDistanceMetric(
"cosine", self.max_cosine_distance, self.nn_budget)
self.tracker = Tracker(self.metric)
self.physical_devices = tf.config.experimental.list_physical_devices(
'GPU')
if len(self.physical_devices) > 0:
tf.config.experimental.set_memory_growth(self.physical_devices[0],
True)
if FLAGS.tiny:
self.yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
self.yolo = YoloV3(classes=FLAGS.num_classes)
self.yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
self.class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
self.fps = 0.0
self.last_tracked = []
def main(_argv):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
for physical_device in physical_devices:
tf.config.experimental.set_memory_growth(physical_device, True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
# Load weights
yolo.load_weights(FLAGS.weights).expect_partial()
logging.info('weights loaded')
# Load classnames
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info(f'classes loaded: {class_names}')
dataset = load_tfrecord_dataset(file_pattern=FLAGS.dataset,
class_file=FLAGS.classes,
size=FLAGS.size)
dataset = dataset.as_numpy_iterator()
times = []
counter = 0
for val_data in tqdm(dataset):
counter += 1
file_name = f"image_size_{im_size}/tiny/score_threshold_{score_threshold}/image-{counter}.txt"
image_name = f"image_size_{im_size}/score_threshold_{score_threshold}/images/image-{counter}.jpeg"
img_raw, _label = val_data
img = tf.expand_dims(img_raw, 0)
img = transform_images(img, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo(img)
t2 = time.time()
times.append([np.subtract(t2, t1)])
logging.info('time: {}'.format(t2 - t1))
if FLAGS.save_images:
img = cv2.cvtColor(img_raw, cv2.COLOR_RGB2BGR)
img = draw_outputs(img, (boxes, scores, classes, nums), class_names, text=True, color=(0, 0, 255), obj=False)
cv2.imwrite(os.path.join(DETECTIONS_DIR, image_name), img)
else:
open(os.path.join(DETECTIONS_DIR, file_name), "w").close()
for i in range(nums[0]):
left, top, right, bottom = np.array(boxes[0][i]) * FLAGS.size
with open(os.path.join(DETECTIONS_DIR, file_name), 'a+') as f:
f.write(f"{class_names[int(classes[0][i])]} "
f"{np.array(scores[0][i])} "
f"{round(Decimal(str(left)), 2)} "
f"{round(Decimal(str(top)), 2)} "
f"{round(Decimal(str(right)), 2)} "
f"{round(Decimal(str(bottom)), 2)}\n")
print(f"Mean detection time for dataset: {data_set_name} "
f"with image size: {im_size} "
f"and score threshold: {score_threshold} is: "
f"{round(np.mean(times), 3)}, fps: {round(1/(np.mean(times)), 2)}")
def main(_argv):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
times = []
vid = cv2.VideoCapture(0, cv2.CAP_DSHOW)
# out = None
if FLAGS.output:
# by default VideoCapture returns float instead of int
width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = int(vid.get(cv2.CAP_PROP_FPS))
# codec = cv2.VideoWriter_fourcc(*FLAGS.output_format)
# out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height))
while True:
_, img = vid.read()
if img is None:
logging.warning("Empty Frame")
time.sleep(0.25)
continue
img_in = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_in = tf.expand_dims(img_in, 0)
img_in = transform_images(img_in, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo.predict(img_in)
t2 = time.time()
times.append(t2 - t1)
times = times[-20:]
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
img = cv2.putText(
img, "Time: {:.2f}ms".format(sum(times) / len(times) * 1000),
(0, 30), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 2)
# if FLAGS.output:
# out.write(img)
cv2.imshow('output', img)
if cv2.waitKey(1) == ord('q'):
break
cv2.destroyAllWindows()
def main(_argv):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
for physical_device in physical_devices:
tf.config.experimental.set_memory_growth(physical_device, True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights).expect_partial()
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
if FLAGS.tfrecord:
dataset = load_tfrecord_dataset(FLAGS.tfrecord, FLAGS.classes,
FLAGS.size)
dataset = dataset.shuffle(512)
img_raw, _label = next(iter(dataset.take(1)))
else:
img_raw = tf.image.decode_image(open(FLAGS.image, 'rb').read(),
channels=3)
img = tf.expand_dims(img_raw, 0)
img = transform_images(img, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo(img)
t2 = time.time()
logging.info('time: {}'.format(t2 - t1))
logging.info('primary detections:')
for i in range(nums[0]):
logging.info('\t{}, {:.2f}'.format(class_names[int(classes[0][i])],
np.array(scores[0][i])))
img = cv2.cvtColor(img_raw.numpy(), cv2.COLOR_RGB2BGR)
t3 = time.time()
img, cat_det, dog_det = draw_outputs(img, (boxes, scores, classes, nums),
class_names)
t4 = time.time()
cv2.imwrite(FLAGS.output, img)
if np.size(cat_det) != 0 or np.size(dog_det) != 0:
logging.info('secondary detections :')
logging.info('time: {}'.format(t4 - t3))
if np.size(cat_det) != 0:
for cat in cat_det:
logging.info('\t{}, {:.2f}'.format(cat[1], cat[0]))
if np.size(dog_det) != 0:
for dog in dog_det:
logging.info('\t {}, {:.2f}'.format(dog[1], dog[0]))
logging.info('output saved to: {}'.format(FLAGS.output))
cv2.imshow(FLAGS.output)
def main(_argv):
# Change flag values
if FLAGS.height is None:
FLAGS.height = FLAGS.size
if FLAGS.width is None:
FLAGS.width = FLAGS.size
size = (FLAGS.height, FLAGS.width)
physical_devices = tf.config.experimental.list_physical_devices('GPU')
for physical_device in physical_devices:
tf.config.experimental.set_memory_growth(physical_device, True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights).expect_partial()
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
if FLAGS.tfrecord:
dataset = load_tfrecord_dataset(FLAGS.tfrecord, FLAGS.classes, size)
dataset = dataset.shuffle(512)
img_iter = iter(dataset.take(FLAGS.count))
else:
img_raw = tf.image.decode_image(open(FLAGS.image, 'rb').read(),
channels=3)
img_iter = iter([(img_raw, None)])
for idx, (img_raw, _label) in enumerate(img_iter):
img = tf.expand_dims(img_raw, 0)
img = transform_images(img, size)
t1 = time.time()
boxes, scores, classes, nums = yolo(img)
t2 = time.time()
logging.info('time: {}'.format(t2 - t1))
logging.info('detections:')
for i in range(nums[0]):
logging.info('\t{}, {}, {}'.format(class_names[int(classes[0][i])],
np.array(scores[0][i]),
np.array(boxes[0][i])))
img = cv2.cvtColor(img_raw.numpy(), cv2.COLOR_RGB2BGR)
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
output = FLAGS.output
if idx != 0:
dot = output.rfind(".")
suffix = "-" + str(idx).zfill(3)
if dot != -1:
output = output[:dot] + suffix + output[dot:]
else:
output = output + suffix
cv2.imwrite(output, img)
logging.info('output saved to: {}'.format(output))
def main(_argv):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
nfp = 0
npp = 0
nxp = 0
files = os.listdir('data/scaled')
for fn in files:
lc = fn[len(fn) - 5]
test_data = lc == '0'
if not flags.FLAGS.all and not test_data:
continue
img = tf.image.decode_image(open('data/scaled/' + fn, 'rb').read(), channels=3)
img = tf.expand_dims(img, 0)
img = transform_images(img, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo(img)
t2 = time.time()
logging.info('time: {}'.format(t2 - t1))
logging.info('detections:')
for i in range(nums[0]):
logging.info('\t{}, {}, {}'.format(class_names[int(classes[0][i])],
np.array(scores[0][i]),
np.array(boxes[0][i])))
nfp += 1
if nums[0] > 0:
npp += 1
img = cv2.imread('data/scaled/' + fn)
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
ofn = 'data/predict/' + fn
if FLAGS.save or test_data:
cv2.imwrite(ofn, img)
logging.info('output saved to: {}'.format(ofn))
if nums[0] == 4:
nxp += 1
print("%d processed. %d some prediction. %d has complete prediction\n" % (nfp, npp, nxp))
print("%1.0f %% pass prediction" % (100 * nxp / nfp))
def main(_argv):
del _argv
if FLAGS.tiny:
yolo = YoloV3Tiny()
else:
yolo = YoloV3()
# yolo.summary()
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
url = images_url.copy()
img = url[0]
img = tf.image.decode_image(open(img, 'rb').read(), channels=3)
img = tf.expand_dims(img, 0)
im = transform_images(img, 416)
for pic in url[1:]:
img1 = tf.image.decode_image(open(pic, 'rb').read(), channels=3)
img1 = tf.expand_dims(img1, 0)
img1 = transform_images(img1, 416)
im = tf.concat((im, img1), axis=0)
print(tf.shape(im))
t1 = time.time()
Tboxes, Tscores, Tclasses, Tnums = yolo(im)
t2 = time.time()
logging.info('time: {}'.format(t2 - t1))
# boxes, scores, classes, nums=a
# print(tf.shape(Tscores[0:1,:]))
# print(tf.shape(Tclasses))
# print(tf.shape(Tboxes))
# print(tf.shape(Tnums[0:1]))
for pic in range(tf.shape(Tnums)):
scores = Tscores[0 + pic:1 + pic, :]
classes = Tclasses[0 + pic:1 + pic, :]
boxes = Tboxes[0 + pic:1 + pic, :, :]
nums = Tnums[0 + pic:1 + pic]
logging.info('detections:')
print(nums[0])
for i in range(nums[0]):
logging.info('\t{}, {}, {}'.format(class_names[int(classes[0][i])],
scores[0][i].numpy(),
boxes[0][i].numpy()))
img = cv2.imread(images_url[pic])
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
cv2.imwrite(str(pic) + '.jpg', img)
logging.info('output saved to: {}'.format('output' + str(pic)))
def main(_argv):
id_img = 0
physical_devices = tf.config.experimental.list_physical_devices('GPU')
for physical_device in physical_devices:
tf.config.experimental.set_memory_growth(physical_device, True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights).expect_partial()
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
logging.info('initialization connexion at {}:{}'.format(FLAGS.ip, str(FLAGS.port)))
connexion_1 = time.time()
sk = nt.init_connexion(FLAGS.ip, FLAGS.port)
connexion_2 = time.time()
connexion = connexion_2 - connexion_1
logging.info("connected to {} port {} in {:.3f}ms".format(FLAGS.ip, FLAGS.port, connexion))
if FLAGS.tfrecord:
dataset = load_tfrecord_dataset(
FLAGS.tfrecord, FLAGS.classes, FLAGS.size)
dataset = dataset.shuffle(512)
img_raw, _label = next(iter(dataset.take(1)))
else:
img_raw = tf.image.decode_image(
open(FLAGS.image, 'rb').read(), channels=3)
img = tf.expand_dims(img_raw, 0)
img = transform_images(img, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo(img)
t2 = time.time()
img = cv2.cvtColor(img_raw.numpy(), cv2.COLOR_RGB2BGR)
nt.get_more_data(img, (boxes, scores, classes, nums), class_names)
logging.info('time: {}'.format(t2 - t1))
logging.info('primary detections:')
for i in range(nums[0]):
logging.info('\t{}, {:.2f}'.format(class_names[int(classes[0][i])],
np.array(scores[0][i])))
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
cv2.imwrite(FLAGS.output, img)
logging.info('output saved to: {}'.format(FLAGS.output))
sk.close()
def main(_argv):
global g_yolo
for i in (1, 2):
S = time.time()
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
t1 = time.time()
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
if g_yolo is not None:
yolo = g_yolo
else:
yolo = YoloV3(classes=FLAGS.num_classes)
g_yolo = yolo
yolo.load_weights(FLAGS.weights).expect_partial()
t2 = time.time()
logging.info('weights loaded')
logging.info(f'graph_construction_time_{i} {t2-t1}')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
if FLAGS.tfrecord:
dataset = load_tfrecord_dataset(FLAGS.tfrecord, FLAGS.classes,
FLAGS.size)
dataset = dataset.shuffle(512)
img_raw, _label = next(iter(dataset.take(1)))
else:
img_raw = tf.image.decode_image(open(FLAGS.image, 'rb').read(),
channels=3)
img = tf.expand_dims(img_raw, 0)
img = transform_images(img, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo(img)
t2 = time.time()
logging.info('inference_time_{} {}'.format(i, t2 - t1))
logging.info('detections:')
for i in range(nums[0]):
logging.info('\t{}, {}, {}'.format(class_names[int(classes[0][i])],
np.array(scores[0][i]),
np.array(boxes[0][i])))
img = cv2.cvtColor(img_raw.numpy(), cv2.COLOR_RGB2BGR)
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
cv2.imwrite(FLAGS.output, img)
logging.info('output saved to: {}'.format(FLAGS.output))
E = time.time()
logging.info(f'phase_{i}_time: {E-S}')
def main(_argv):
if FLAGS.tiny:
yolo = YoloV3Tiny()
else:
yolo = YoloV3()
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
times = []
try:
vid = cv2.VideoCapture(int(FLAGS.video))
vid.set(3, 3840)
vid.set(4, 2160)
vid.set(5, 10)
except:
vid = cv2.VideoCapture(FLAGS.video)
frame_width = int(vid.get(3))
frame_height = int(vid.get(4))
vid_out = cv2.VideoWriter(FLAGS.output_video,
cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 30.0,
(frame_width, frame_height))
while True:
_, img = vid.read()
if img is None:
logging.warning("Empty Frame")
time.sleep(0.1)
break
img_in = tf.expand_dims(img, 0)
img_in = transform_images(img_in, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo.predict(img_in)
t2 = time.time()
times.append(t2 - t1)
times = times[-20:]
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
img = cv2.putText(
img, "Time: {:.2f}ms".format(sum(times) / len(times) * 1000),
(0, 30), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255), 2)
vid_out.write(img)
cv2.imshow('output', img)
if cv2.waitKey(1) == ord('q'):
break
vid_out.release()
vid.release()
cv2.destroyAllWindows()
def main(_argv):
#%%
if FLAGS.tiny:
yolo = YoloV3Tiny()
else:
yolo = YoloV3()
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
times = []
cap = cv2.VideoCapture(FLAGS.url)
out = cv2.VideoWriter(
'appsrc ! videoconvert ! '
'x264enc noise-reduction=10000 speed-preset=ultrafast tune=zerolatency ! '
'rtph264pay config-interval=1 pt=96 !'
'tcpserversink host=140.117.169.194 port=5000 sync=false', 0, 25,
(640, 480))
out_path = './out/'
if not os.path.exists(out_path):
os.makedirs(out_path)
#%%
while (cap.isOpened()):
ret, img = cap.read()
if cv2.waitKey(20) & 0xFF == ord('q'):
break
img_in = tf.expand_dims(img, 0)
img_in = transform_images(img_in, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo.predict(img_in)
t2 = time.time()
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
img = cv2.putText(
img, "Time: {:.2f}ms".format(sum(times) / len(times) * 1000),
(0, 30), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 2)
# if(nums > 0):
# cv2.imwrite(out_path + 'frame{0}.jpg'.format(index), img)
frameOfWindows = cv2.resize(img, (800, 600),
interpolation=cv2.INTER_CUBIC)
out.write(frameOfWindows)
cv2.imshow('output', frameOfWindows)
if cv2.waitKey(1) == ord('q'):
break
cap.release()
def main(_argv):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
times = []
fps = 0.0
#count = 0
while True:
# capturing a part of the screen with resulation (1200,1200)px
img = ImageGrab.grab(bbox=(50, 50, 950, 950),
all_screens=True) # x, y, w, h
img = np.array(img)
_ = True
img_in = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_in = tf.expand_dims(img_in, 0)
img_in = transform_images(img_in, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo.predict(img_in)
fps = (fps + (1. / (time.time() - t1))) / 2
img, objekt_dim, marra = draw_outputs(img,
(boxes, scores, classes, nums),
class_names)
img = cv2.putText(
img, "Das Code wird von ersten Gruppe_I erstellt " +
str(int(fps)) + " (fps)", (0, 30), cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (255, 0, 0), 1)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
cv2.imshow("Gruppe_I", img)
if cv2.waitKey(1) == ord('q'):
break
cv2.destroyAllWindows()
def main(_argv):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
if FLAGS.tiny:
print("yolo used is tiny model")
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
print("yolo used is full model")
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights).expect_partial()
print('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
print('classes loaded')
if FLAGS.tfrecord:
dataset = load_tfrecord_dataset(FLAGS.tfrecord, FLAGS.classes,
FLAGS.size)
dataset = dataset.shuffle(512)
img_raw, _label = next(iter(dataset.take(1)))
else:
raw_images = []
images = FLAGS.images
for image in images:
img_raw = tf.image.decode_image(open(image, 'rb').read(),
channels=3)
raw_images.append(img_raw)
num = 0
for raw_img in raw_images:
num += 1
img = tf.expand_dims(raw_img, 0)
img = transform_images(img, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo(img)
t2 = time.time()
logging.info('time: {}'.format(t2 - t1))
print('detections:')
for i in range(nums[0]):
print('\t{}, {}, {}'.format(class_names[int(classes[0][i])],
np.array(scores[0][i]),
np.array(boxes[0][i])))
img = cv2.cvtColor(raw_img.numpy(), cv2.COLOR_RGB2BGR)
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
cv2.imwrite(FLAGS.output + 'detection' + str(num) + '.jpg', img)
print('output saved to: {}'.format(FLAGS.output + 'detection' +
str(num) + '.jpg'))
def main(_argv):
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.summary()
logging.info('model created')
load_darknet_weights(yolo, FLAGS.weights, FLAGS.tiny)
logging.info('weights loaded')
img = np.random.random((1, 320, 320, 3)).astype(np.float32)
output = yolo(img)
logging.info('sanity check passed')
yolo.save_weights(FLAGS.output)
logging.info('weights saved')
def main(_argv):
print("Start")
start_time = time.time()
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
logging.info('classes loaded')
times = []
try:
vid = cv2.VideoCapture(int(FLAGS.video))
except:
vid = cv2.VideoCapture(FLAGS.video)
out = None
if FLAGS.output:
# by default VideoCapture returns float instead of int
width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = int(vid.get(cv2.CAP_PROP_FPS))
codec = cv2.VideoWriter_fourcc(*FLAGS.output_format)
out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height))
with ThreadPoolExecutor(max_workers=1) as executor:
executor.submit(img_read_wrapper, vid, processed_img_queue,
raw_img_queue)
executor.submit(predict_wrapper, yolo, processed_img_queue,
yolo_result_queue)
display_wrapper(out, FLAGS, yolo_result_queue, raw_img_queue)
# read_thread = threading.Thread(target=img_read_wrapper, args=(vid, processed_img_queue, raw_img_queue))
# predict_thread = threading.Thread(target=predict_wrapper, args=(yolo, processed_img_queue, yolo_result_queue))
# display_thread = threading.Thread(target=display_wrapper, args=(out, FLAGS, yolo_result_queue, raw_img_queue))
# threads = [read_thread, predict_thread, display_thread]
# for t in threads:
# t.start()
# for t in threads:
# t.join()
print("FInish", time.time() - start_time)
def main(_argv):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
for physical_device in physical_devices:
tf.config.experimental.set_memory_growth(physical_device, True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights).expect_partial()
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
if FLAGS.tfrecord:
dataset = load_tfrecord_dataset(FLAGS.tfrecord, FLAGS.classes,
FLAGS.size)
dataset = dataset.shuffle(512)
img_raw, _label = next(iter(dataset.take(1)))
else:
img_raw = tf.image.decode_image(open(FLAGS.image, 'rb').read(),
channels=3)
img = tf.expand_dims(img_raw, 0)
img = transform_images(img, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo(img)
t2 = time.time()
logging.info('time: {}'.format(t2 - t1))
logging.info('detections:')
for i in range(nums[0]):
logging.info('\t{}, {}, {}'.format(class_names[int(classes[0][i])],
np.array(scores[0][i]),
np.array(boxes[0][i])))
img = cv2.cvtColor(img_raw.numpy(), cv2.COLOR_RGB2BGR)
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
cv2.imshow("result", img)
k = cv2.waitKey(0)
if k & 0xFF == ord('q'):
cv2.destroyAllWindows()
if k == ord('s'):
cv2.imwrite(FLAGS.output, img)
logging.info('output saved to: {}'.format(FLAGS.output))
cv2.destroyAllWindows()
def main(_argv):
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
tf.saved_model.save(yolo, FLAGS.output)
logging.info("model saved to: {}".format(FLAGS.output))
model = tf.saved_model.load(FLAGS.output)
infer = model.signatures[tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY]
logging.info(infer.structured_outputs)
def main(_argv):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
times = []
try:
vid = cv2.VideoCapture(int(FLAGS.video))
except:
vid = cv2.VideoCapture(FLAGS.video)
while True:
_, img = vid.read()
if img is None:
logging.warning("Empty Frame")
time.sleep(0.1)
continue
img_in = tf.expand_dims(img, 0)
img_in = transform_images(img_in, FLAGS.size)
t1 = time.time()
boxes, scores, classes, nums = yolo.predict(img_in)
t2 = time.time()
times.append(t2 - t1)
times = times[-20:]
img = draw_outputs(img, (boxes, scores, classes, nums), class_names)
img = cv2.putText(
img, "Time: {:.2f}ms".format(sum(times) / len(times) * 1000),
(0, 30), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 2)
cv2.imshow('output', img)
if cv2.waitKey(1) == ord('q'):
break
cv2.destroyAllWindows()
def main(_argv):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
for physical_device in physical_devices:
tf.config.experimental.set_memory_growth(physical_device, True)
if FLAGS.tiny:
yolo = YoloV3Tiny(classes=FLAGS.num_classes)
else:
yolo = YoloV3(classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights).expect_partial()
logging.info('weights loaded')
dataset = load_tfrecord_dataset(
FLAGS.tfrecord, FLAGS.classes, FLAGS.size)
total_matched = 0
total_count = 0
total_iou = 0
false_detected = 0
for img_raw, _label in tqdm(dataset):
_label = _label.numpy()
true_labels = np.sum(np.sum(_label, axis=1) > 0)
img = tf.expand_dims(img_raw, 0)
img = transform_images(img, FLAGS.size)
boxes, scores, classes, nums = yolo(img)
total_count += true_labels
for i in range(nums[0]):
iou = 0
for i_true in range(true_labels):
if _label[i_true][-1] != int(classes[0][i]):
continue
iou_current = bb_intersection_over_union(_label[i_true][:4], np.array(boxes[0][i]))
if iou_current > iou:
iou = iou_current
if iou > 0:
total_matched += 1
else:
false_detected += 1
total_iou += iou
logging.info(f'Total objects: {total_count}\n\t matched: {total_matched} ratio: {total_matched / total_count:.3}\n\t false detected: {false_detected}\n\tavgIOU: {total_iou / total_count:.3} matched avgIOU: {total_iou / total_matched:.3}')
def main(_argv):
if FLAGS.tiny:
yolo = YoloV3Tiny(size=FLAGS.size, classes=FLAGS.num_classes)
else:
yolo = YoloV3(size=FLAGS.size, classes=FLAGS.num_classes)
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
converter = tf.lite.TFLiteConverter.from_keras_model(yolo)
converter.target_ops = [
tf.lite.OpsSet.TFLITE_BUILTINS, tf.lite.OpsSet.SELECT_TF_OPS
]
converter.allow_custom_ops = True
tflite_model = converter.convert()
open(FLAGS.output, 'wb').write(tflite_model)
logging.info("model saved to: {}".format(FLAGS.output))
