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()
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):
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 post(self, request):
yolo = YoloV3(classes=8)
yolo.load_weights('./checkpoints/yolov3_train.tf').expect_partial()
class_names = [c.strip() for c in open('./checkpoints/chestx.names').readlines()]
img_raw = tf.image.decode_image(
request.data['image'].read(), channels=3)
img = tf.expand_dims(img_raw, 0)
img = transform_images(img, 416)
boxes, scores, classes, nums = yolo(img)
arr = []
for i in range(nums[0]):
arr.append(class_names[int(classes[0][i])])
return JsonResponse({'pred':arr})
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(_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):
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')
img = tf.image.decode_jpeg(open(FLAGS.image, 'rb').read(), channels=3)
img = tf.expand_dims(img, 0)
img = transform_images(img, size)
tf.print(img)
t1 = time.time()
boxes, scores, classes, nms = yolo(img)
t2 = time.time()
logging.info('time: {}'.format(t2 - t1))
logging.info('detections:')
tf.print(nms)
tf.print(boxes, scores, classes, nms)
# range_nms = nms[0].to_int64
for i in range(1):
print("Did I enter? ")
print("class_name: ", class_names[int(classes[0][i])])
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, nms), class_names)
cv2.imwrite(FLAGS.output, img)
logging.info('output saved to: {}'.format(FLAGS.output))
def initialize_yolo(self):
self.__yolo = YoloV3(classes=FLAGS.num_classes)
self.__yolo.load_weights(FLAGS.weights).expect_partial()
logging.info('weights loaded')
self.__class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
def __init__(self):
print("Initializied test service for tf2")
# Get Yolov3 Model
self.yolo = YoloV3(classes=80)
self.yolo.load_weights(WEIGHTS)
self.class_names = [c.strip() for c in open(CLASSES).readlines()]
print("Loaded Yolov3 model and weights.")
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):
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):
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):
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 detect_tfrecord_batch(record_path,
weights='./yolov3_tf2/yolov3_model.tf',
classes='./yolov3_tf2/particle.names',
num_classes=1,
size=416,
tiny=False,
batch_size=12):
for filePath in glob.glob("./yolov3_tf2/tmp/*.txt"):
os.remove(filePath)
yolo = YoloV3(classes=num_classes)
yolo.load_weights(weights).expect_partial()
logging.info('weights loaded: ' + weights)
class_names = [c.strip() for c in open(classes).readlines()]
logging.info('classes loaded: ' + classes)
dataset = load_tfrecord_dataset(record_path, classes, size)
tot1 = 0
tot2 = 0
times = []
imgs = []
ret = []
for img_raw, label_raw in iter(dataset):
tot1 += 1
imgs.append(img_raw)
if tot1 % batch_size == 0:
imgs = transform_images(imgs, size, random=False)
t1 = time.time()
boxes, scores, classes, nums = yolo.predict(imgs)
t2 = time.time()
times.append(t2 - t1)
for k in range(len(nums)):
ret.append([])
for i in range(nums[k]):
ret[len(ret) - 1].append([
boxes[k][i][0] * size, boxes[k][i][1] * size,
boxes[k][i][2] * size, boxes[k][i][3] * size,
scores[k][i]
])
tot2 += 1
imgs = []
if len(imgs) != 0:
imgs = transform_images(imgs, size, random=False)
boxes, scores, classes, nums = yolo.predict(imgs)
for k in range(len(nums)):
ret.append([])
for i in range(nums[k]):
ret[len(ret) - 1].append([
boxes[k][i][0] * size, boxes[k][i][1] * size,
boxes[k][i][2] * size, boxes[k][i][3] * size, scores[k][i]
])
tot2 += 1
logging.info("total number of images: {}".format(tot1))
logging.info('Time: {:.2f} ms'.format(
np.average(np.asarray(times)) * 1000))
return ret
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')
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 Load_DeepFashion2_Yolov3():
t1 = time.time()
model = YoloV3(classes=13)
model.load_weights('./built_model/deepfashion2_yolov3')
t2 = time.time()
print('Load DeepFashion2 Yolo-v3 from disk: {:.2f} sec'.format(t2 - t1))
return model
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):
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):
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(args):
class_path = args.classes # Path to classes file
weights = args.weights # Path to weight file
image_size = cfg.IMAGE_SIZE # Resize images to size - 416 04 608
image = '' # Path to input image
tfrecord = args.dataset # tfrecord instead of image or None
output = args.output # Path to output image
num_classes = args.num_classes # Number of classes in model
anchors = cfg.YOLO_ANCHORS
anchor_masks = cfg.YOLO_ANCHOR_MASKS
physical_devices = tf.config.experimental.list_physical_devices('GPU')
for physical_device in physical_devices:
tf.config.experimental.set_memory_growth(physical_device, True)
yolo = YoloV3(image_size, training=False, classes=num_classes)
yolo.load_weights(weights).expect_partial()
print('weights loaded')
class_names = [c.strip() for c in open(class_path).readlines()]
print('classes loaded')
if tfrecord:
val_dataset = load_tfrecord_dataset(tfrecord, class_path, image_size)
# val_dataset = val_dataset.shuffle(512)
val_dataset = val_dataset.batch(1)
val_dataset = val_dataset.map(lambda x, y: (
transform_images(x, image_size),
transform_targets(y, anchors, anchor_masks, image_size)))
# img_raw, _label = next(iter(dataset.take(1)))
else:
img_raw = tf.image.decode_image(open(image, 'rb').read(), channels=3)
index = 0
for img_raw, _label in val_dataset.take(25):
# img = tf.expand_dims(img_raw, 0)
img = transform_images(img_raw, image_size)
img = img * 255
boxes, scores, classes, nums = yolo(img)
output = '/Users/justinbutler/Desktop/test/test_images/test_{}.jpg'.format(
index)
output = '/home/justin/Models/yolov3-tf2/test_images/test_{}.jpg'.format(
index)
print('output saved to: {}'.format(output))
img = cv2.cvtColor(img_raw[0].numpy(), cv2.COLOR_RGB2BGR)
img = draw_outputs(img, (boxes, scores, classes, nums),
class_names,
thresh=0)
img = img * 255
cv2.imwrite(output, img)
index = index + 1
def __init__(self):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
self.yolo = YoloV3(classes=80)
self.yolo.load_weights('./model_data/yolov3.tf')
self.class_names = [
c.strip()
for c in open('./model_data/coco_classes.txt').readlines()
]
def __init__(self):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
for physical_device in physical_devices:
tf.config.experimental.set_memory_growth(physical_device, True)
# Get Yolov3 Model
self.yolo = YoloV3(classes=80)
self.yolo.load_weights(WEIGHTS)
self.class_names = [c.strip() for c in open(CLASSES).readlines()]
print("Yolov3-tf2 service is initialized.")
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()
