def saved_model_inference(self, image_path_pattern, output_dir, **kwargs):
"""Perform inference for the given saved model."""
driver = inference.ServingDriver(self.model_name,
self.ckpt_path,
batch_size=self.batch_size,
enable_ema=self.enable_ema,
use_xla=self.use_xla,
data_format=self.data_format,
**kwargs)
driver.load(self.saved_model_dir)
batch_size = self.batch_size
all_files = list(tf.io.gfile.glob(image_path_pattern))
num_batches = len(all_files) // batch_size
for i in range(num_batches):
batch_files = all_files[i * batch_size:(i + 1) * batch_size]
raw_images = [np.array(Image.open(f)) for f in batch_files]
detections_bs = driver.serve_images(raw_images)
for j in range(len(raw_images)):
img = driver.visualize(raw_images[j], detections_bs[j],
**kwargs)
img_id = str(i * batch_size + j)
output_image_path = os.path.join(output_dir, img_id + '.jpg')
Image.fromarray(img).save(output_image_path)
logging.info('writing file to %s', output_image_path)
def saved_model_inference(self, image_path_pattern, output_dir, **kwargs):
"""Perform inference for the given saved model."""
driver = inference.ServingDriver(
self.model_name,
self.ckpt_path,
batch_size=self.batch_size,
use_xla=self.use_xla,
model_params=self.model_config.as_dict(),
**kwargs)
driver.load(self.saved_model_dir)
# Serving time batch size should be fixed.
batch_size = self.batch_size or 1
all_files = list(tf.io.gfile.glob(image_path_pattern))
print('all_files=', all_files)
num_batches = len(all_files) // batch_size
for i in range(num_batches):
batch_files = all_files[i * batch_size:(i + 1) * batch_size]
raw_images = [np.array(Image.open(f)) for f in batch_files]
detections_bs = driver.serve_images(raw_images)
for j in range(len(raw_images)):
img = driver.visualize(raw_images[j], detections_bs[j],
**kwargs)
img_id = str(i * batch_size + j)
output_image_path = os.path.join(output_dir, img_id + '.jpg')
Image.fromarray(img).save(output_image_path)
logging.info('writing file to %s', output_image_path)
def export_saved_model(self, **kwargs):
tf.enable_resource_variables()
driver = inference.ServingDriver(self.model_name, self.ckpt_path,
self.image_size)
driver.build(min_score_thresh=kwargs.get('min_score_thresh', 0.2),
max_boxes_to_draw=kwargs.get('max_boxes_to_draw', 50))
driver.export(self.saved_model_dir)
def export_saved_model(self, **kwargs):
"""Export a saved model for inference."""
tf.enable_resource_variables()
driver = inference.ServingDriver(self.model_name,
self.ckpt_path,
enable_ema=self.enable_ema)
driver.build(params_override=self.model_overrides,
min_score_thresh=kwargs.get('min_score_thresh', 0.2),
max_boxes_to_draw=kwargs.get('max_boxes_to_draw', 50))
driver.export(self.saved_model_dir)
def saved_model_benchmark(self, image_path_pattern):
"""Perform inference for the given saved model."""
driver = inference.ServingDriver(self.model_name,
self.ckpt_path,
enable_ema=self.enable_ema)
driver.load(self.saved_model_dir)
raw_images = []
image = Image.open(image_path_pattern)
raw_images.append(np.array(image))
driver.benchmark(raw_images)
def saved_model_inference(self, image_dir, output_dir, **kwargs):
"""Perform inference for the given saved model."""
driver = inference.ServingDriver(
self.model_name,
self.ckpt_path,
batch_size=self.batch_size,
use_xla=self.use_xla,
model_params=self.model_config.as_dict(),
**kwargs)
driver.load(self.saved_model_dir)
# Serving time batch size should be fixed.
batch_size = self.batch_size or 1
# all_files = list(tf.io.gfile.listdir(image_dir))
all_files = []
for image in os.listdir(image_dir):
image_file_name = image_dir + '/' + image
all_files.append(image_file_name)
print('all_files=', all_files)
num_batches = (len(all_files) + batch_size - 1) // batch_size
for i in range(num_batches):
batch_files = all_files[i * batch_size:(i + 1) * batch_size]
height, width = self.model_config.image_size
images = [Image.open(f) for f in batch_files]
if len(set([m.size for m in images])) > 1:
# Resize only if images in the same batch have different sizes.
images = [m.resize(height, width) for m in images]
raw_images = [np.array(m) for m in images]
size_before_pad = len(raw_images)
if size_before_pad < batch_size:
padding_size = batch_size - size_before_pad
raw_images += [np.zeros_like(raw_images[0])] * padding_size
detections_bs = driver.serve_images(raw_images)
for j in range(size_before_pad):
img = driver.visualize(raw_images[j], detections_bs[j],
**kwargs)
img_id = str(i * batch_size + j)
output_image_path = os.path.join(output_dir, img_id + '.jpg')
Image.fromarray(img).save(output_image_path)
logging.info('writing file to %s', output_image_path)
# 输出向量
output_tensor_path = os.path.join(output_dir, img_id + '.txt')
try:
f = open(output_tensor_path, 'w+')
f.write('detections_bs\n')
f.write('# Array shape: {0}\n'.format(
detections_bs[j].shape))
f.write(
'[image_id,ymin, xmin, ymax, xmax, score, class]\n')
np.savetxt(output_tensor_path, detections_bs[j])
finally:
if f:
f.close()
def export_saved_model(self, **kwargs):
"""Export a saved model for inference."""
tf.enable_resource_variables()
driver = inference.ServingDriver(self.model_name,
self.ckpt_path,
enable_ema=self.enable_ema,
use_xla=self.use_xla,
data_format=self.data_format,
**kwargs)
driver.build(params_override=self.model_overrides)
driver.export(self.saved_model_dir)
def export_saved_model(self, **kwargs):
"""Export a saved model for inference."""
tf.enable_resource_variables()
driver = inference.ServingDriver(
self.model_name,
self.ckpt_path,
batch_size=self.batch_size,
use_xla=self.use_xla,
model_params=self.model_config.as_dict(),
**kwargs)
driver.build()
driver.export(self.saved_model_dir, self.tflite_path, self.tensorrt)
def saved_model_benchmark(self, image_path_pattern, **kwargs):
"""Perform inference for the given saved model."""
driver = inference.ServingDriver(self.model_name,
self.ckpt_path,
enable_ema=self.enable_ema,
use_xla=self.use_xla,
data_format=self.data_format,
**kwargs)
driver.load(self.saved_model_dir)
raw_images = []
image = Image.open(image_path_pattern)
raw_images.append(np.array(image))
driver.benchmark(raw_images, FLAGS.trace_filename)
def saved_model_inference(self, image_path_pattern, output_dir, **kwargs):
"""Perform inference for the given saved model."""
driver = inference.ServingDriver(self.model_name,
self.ckpt_path,
enable_ema=self.enable_ema)
driver.load(self.saved_model_dir)
raw_images = []
image = Image.open(image_path_pattern)
raw_images.append(np.array(image))
detections_bs = driver.serve_images(raw_images)
for i, detections in enumerate(detections_bs):
img = driver.visualize(raw_images[i], detections, **kwargs)
output_image_path = os.path.join(output_dir, str(i) + '.jpg')
Image.fromarray(img).save(output_image_path)
logging.info('writing file to %s', output_image_path)
def saved_model_video(self, video_path: Text, output_video: Text,
**kwargs):
"""Perform video inference for the given saved model."""
import cv2 # pylint: disable=g-import-not-at-top
driver = inference.ServingDriver(
self.model_name,
self.ckpt_path,
batch_size=1,
use_xla=self.use_xla,
model_params=self.model_config.as_dict(),
)
driver.load(self.saved_model_dir)
cap = cv2.VideoCapture(video_path)
if not cap.isOpened():
print("Error opening input video: {}".format(video_path))
out_ptr = None
if output_video:
frame_width, frame_height = int(cap.get(3)), int(cap.get(4))
out_ptr = cv2.VideoWriter(
output_video,
cv2.VideoWriter_fourcc("m", "p", "4", "v"),
25,
(frame_width, frame_height),
)
while cap.isOpened():
# Capture frame-by-frame
ret, frame = cap.read()
if not ret:
break
raw_frames = [np.array(frame)]
detections_bs = driver.serve_images(raw_frames)
new_frame = driver.visualize(raw_frames[0], detections_bs[0],
**kwargs)
if out_ptr:
# write frame into output file.
out_ptr.write(new_frame)
else:
# show the frame online, mainly used for real-time speed test.
cv2.imshow("Frame", new_frame)
# Press Q on keyboard to exit
if cv2.waitKey(1) & 0xFF == ord("q"):
break
def saved_model_benchmark(self, image_path_pattern, **kwargs):
"""Perform inference for the given saved model."""
driver = inference.ServingDriver(
self.model_name,
self.ckpt_path,
batch_size=self.batch_size,
use_xla=self.use_xla,
model_params=self.model_config.as_dict(),
**kwargs)
driver.load(self.saved_model_dir)
raw_images = []
all_files = list(tf.io.gfile.glob(image_path_pattern))
if len(all_files) < self.batch_size:
all_files = all_files * (self.batch_size // len(all_files) + 1)
raw_images = [np.array(Image.open(f)) for f in all_files[:self.batch_size]]
driver.benchmark(raw_images, FLAGS.trace_filename)
def saved_model_inference(self, image_path_pattern, output_dir, **kwargs):
"""Perform inference for the given saved model."""
with tf.Session() as sess:
tf.saved_model.load(sess, ['serve'], self.saved_model_dir)
raw_images = []
image = Image.open(image_path_pattern)
raw_images.append(np.array(image))
detections_bs = sess.run('detections:0',
{'image_arrays:0': raw_images})
driver = inference.ServingDriver(self.model_name, self.ckpt_path,
self.image_size)
for i, detections in enumerate(detections_bs):
print('detections[:10]=', detections[:10])
img = driver.visualize(raw_images[i], detections, **kwargs)
output_image_path = os.path.join(output_dir, str(i) + '.jpg')
Image.fromarray(img).save(output_image_path)
logging.info('writing file to %s', output_image_path)
def saved_model_inference(self, image_path_pattern, output_dir, **kwargs):
"""Perform inference for the given saved model."""
driver = inference.ServingDriver(
self.model_name,
self.ckpt_path,
batch_size=self.batch_size,
use_xla=self.use_xla,
model_params=self.model_config.as_dict(),
**kwargs)
driver.load(self.saved_model_dir)
# Serving time batch size should be fixed.
batch_size = self.batch_size or 1
all_files = list(tf.io.gfile.glob(image_path_pattern))
print('all_files=', all_files)
num_batches = (len(all_files) + batch_size - 1) // batch_size
for i in range(num_batches):
batch_files = all_files[i * batch_size:(i + 1) * batch_size]
height, width = self.model_config.image_size
images = [Image.open(f) for f in batch_files]
if len(set([m.size for m in images])) > 1:
# Resize only if images in the same batch have different sizes.
images = [m.resize(height, width) for m in images]
raw_images = [np.array(m) for m in images]
size_before_pad = len(raw_images)
if size_before_pad < batch_size:
padding_size = batch_size - size_before_pad
raw_images += [np.zeros_like(raw_images[0])] * padding_size
detections_bs = driver.serve_images(raw_images)
for j in range(size_before_pad):
img = driver.visualize(raw_images[j], detections_bs[j],
**kwargs)
img_id = str(i * batch_size + j)
output_image_path = os.path.join(output_dir, img_id + '.jpg')
Image.fromarray(img).save(output_image_path)
print('writing file to %s' % output_image_path)
print(detections_bs.dtype)
np.save("filename.npy", detections_bs)
return detections_bs
def main(_):
#do magic with model_config
model_config = hparams_config.get_detection_config(FLAGS.model_name)
model_config.override(FLAGS.hparams) # Add custom overrides
model_config.is_training_bn = False
model_config.image_size = utils.parse_image_size(model_config.image_size)
model_config.nms_configs.score_thresh = FLAGS.min_score_thresh
model_config.nms_configs.method = FLAGS.nms_method
model_config.nms_configs.max_output_size = FLAGS.max_boxes_to_draw
client = microserviceclient.MicroserviceClient("efficientdetservice_" +
FLAGS.service_name)
driver = inference.ServingDriver(FLAGS.model_name,
FLAGS.ckpt_path,
batch_size=1,
use_xla=FLAGS.use_xla,
model_params=model_config.as_dict())
driver.load(FLAGS.saved_model_dir)
def on_binaryNotification_handler(methodName, payload):
nonlocal driver
nonlocal client
if methodName == "doInferencePlease":
frame = cv2.imdecode(
np.asarray(bytearray(payload), dtype=np.uint8),
cv2.IMREAD_COLOR)
raw_frames = [np.array(frame)]
detections_bs = driver.serve_images(raw_frames)
client.notify("inferenceResult", driver.to_json(detections_bs[0]))
#new_frame = driver.visualize(raw_frames[0], detections_bs[0], min_score_thresh=FLAGS.min_score_thresh, max_boxes_to_draw=FLAGS.max_boxes_to_draw, line_thickness=FLAGS.line_thickness )
#res, boxedFrame = cv2.imencode('.jpg', new_frame)
#client.binaryNotify("inferenceResult", boxedFrame.tobytes())
client.on_binaryNotification = on_binaryNotification_handler
client.start()
while True:
time.sleep(0.10)
client.stop()
def saved_model_webcam(self, webcam_idx, **kwargs):
"""Perform webcam inference for the given saved model."""
import cv2 # pylint: disable=g-import-not-at-top
driver = inference.ServingDriver(
self.model_name,
self.ckpt_path,
batch_size=1,
use_xla=self.use_xla,
model_params=self.model_config.as_dict())
driver.load(self.saved_model_dir)
cap = cv2.VideoCapture(int(webcam_idx))
if not cap.isOpened():
print('Error opening input: {}'.format('webcam'))
err_cnt = 0
while cap.isOpened():
# Capture frame-by-frame
ret, frame = cap.read()
if not ret:
if err_cnt < 20:
err_cnt += 1
continue
else:
print('Error retrieving images: {}'.format('webcam'))
break
raw_frames = [np.array(frame)]
detections_bs = driver.serve_images(raw_frames)
json_str = driver.to_json(detections_bs[0])
new_frame = driver.visualize(raw_frames[0], detections_bs[0],
**kwargs)
# show the frame online, mainly used for real-time speed test.
cv2.imshow('Frame', new_frame)
# Press Q on keyboard to exit
if cv2.waitKey(1) & 0xFF == ord('q'):
break
def export_pb_model_image_arrays(self):
driver = inference.ServingDriver(self.model_name, self.ckpt_path)
driver.build()
driver.save_inference_pb_model_from_raw_image(self.saved_model_dir)
def saved_model_inference(self, image_path_pattern, output_dir, **kwargs):
"""Perform inference for the given saved model."""
driver = inference.ServingDriver(
self.model_name,
self.ckpt_path,
batch_size=self.batch_size,
use_xla=self.use_xla,
model_params=self.model_config.as_dict(),
**kwargs)
driver.load(self.saved_model_dir)
# Serving time batch size should be fixed. See new version of Google's Repo
batch_size = self.batch_size or 1
all_files = list(tf.io.gfile.glob(image_path_pattern))
print('all_files=', all_files)
if not FLAGS.big_image:
num_batches = len(all_files) // batch_size
for i in range(num_batches):
batch_files = all_files[i * batch_size:(i + 1) * batch_size]
raw_images = [np.array(Image.open(f)) for f in batch_files]
detections_bs = driver.serve_images(raw_images)
for j in range(len(raw_images)):
img = driver.visualize(raw_images[j], detections_bs[j],
**kwargs)
img_id = str(i * batch_size + j)
output_image_path = os.path.join(output_dir,
img_id + '.jpg')
Image.fromarray(img).save(output_image_path)
logging.info('writing file to %s', output_image_path)
else:
for f in all_files:
with Image.open(f) as im:
img_name = os.path.basename(f)
image_width = im.width
image_height = im.height
imagette_width = self.model_config.image_size[0]
imagette_height = self.model_config.image_size[1]
divx = round(int(image_width) / imagette_width)
divy = round(int(image_height) / imagette_height)
size = (imagette_width * divx, imagette_height * divy)
im_resized = im.resize(size)
imagettes = []
if FLAGS.raster:
raster_image = np.zeros(size[::-1])
eval_image = Image.new('RGB', size)
eval_time = 0
for x in range(divx):
for y in range(divy):
imagettes = [(np.array(
im_resized.crop(
(x * imagette_width, y * imagette_height,
(x + 1) * imagette_width,
(y + 1) * imagette_height))))]
# driver.batch_size = len(imagettes) # TODO: handle batch size
start = time.time()
detections_bs = driver.serve_images(imagettes)
eval_time += time.time() - start
if FLAGS.raster:
raster_imagette2 = np.zeros(
shape=(imagette_height, imagette_width))
for detection_bs in detections_bs[0]:
ymin = detection_bs[1]
xmin = detection_bs[2]
ymax = detection_bs[3]
xmax = detection_bs[4]
raster_imagette = np.zeros(
shape=(imagette_height,
imagette_width))
raster_imagette[
int(ymin):int(ymax),
int(xmin):int(xmax)] = detection_bs[5]
raster_imagette2 = np.maximum(
raster_imagette2, raster_imagette)
raster_image[y * imagette_height:(y + 1) *
imagette_height,
x * imagette_width:(x + 1) *
imagette_width] = raster_imagette2
eval_imagette = driver.visualize(
imagettes[0], detections_bs[0], **kwargs)
eval_image.paste(
Image.fromarray(eval_imagette),
(x * imagette_width, y * imagette_height,
(x + 1) * imagette_width,
(y + 1) * imagette_height))
print("EfficientDet detection in %s seconds ---" %
(eval_time))
if FLAGS.raster:
raster_image = (raster_image > driver.min_score_thresh
) * raster_image * 255
raster_image = raster_image.astype(np.uint8)
output_raster_path = os.path.join(
output_dir, img_name[:-4] +
'_EfficientDet_detection_raster.png')
ras_img = Image.fromarray(raster_image)
ras_img2 = ras_img.resize(im.size)
ras_img2.save(output_raster_path, "PNG")
output_image_path = os.path.join(
output_dir,
img_name[:-4] + '_EfficientDet_detection.jpg')
eval_image_resized = eval_image.resize(
(im.width, im.height))
eval_image_resized.save(output_image_path)
logging.info('writing file to %s', output_image_path)
def saved_model_inference(self, image_path_pattern, output_dir, **kwargs):
"""Perform inference for the given saved model."""
driver = inference.ServingDriver(
self.model_name,
self.ckpt_path,
batch_size=self.batch_size,
use_xla=self.use_xla,
model_params=self.model_config.as_dict(),
**kwargs)
driver.load(self.saved_model_dir)
# Serving time batch size should be fixed.
batch_size = self.batch_size or 1
all_files = list(tf.io.gfile.glob(image_path_pattern))
print('all_files=', all_files)
num_batches = (len(all_files) + batch_size - 1) // batch_size
parent_dirname = os.path.dirname(image_path_pattern)
model = os.path.basename(os.path.normpath(parent_dirname))
output_folder = os.path.join(output_dir, model)
if not os.path.exists(output_folder):
os.mkdir(output_folder)
if not os.path.exists('logs'):
os.mkdir('logs')
log = open('logs/' + model + '.csv', 'w')
log.write('name,num_boxes,ymin,xmin,ymax,xmax,score,class\n')
for i in range(num_batches):
batch_files = all_files[i * batch_size:(i + 1) * batch_size]
height, width = self.model_config.image_size
images = [Image.open(f) for f in batch_files]
if len(set([m.size for m in images])) > 1:
# Resize only if images in the same batch have different sizes.
images = [m.resize(height, width) for m in images]
raw_images = [np.array(m) for m in images]
size_before_pad = len(raw_images)
if size_before_pad < batch_size:
padding_size = batch_size - size_before_pad
raw_images += [np.zeros_like(raw_images[0])] * padding_size
print([all_files[i * batch_size + j].split('/')[-1] for j in range(size_before_pad)])
detections_bs = driver.serve_images(raw_images)
for j in range(size_before_pad):
img_id = i * batch_size + j
filename = all_files[img_id].split('/')[-1]
output_image_path = os.path.join(output_folder, filename)
# if os.path.exists(output_image_path):
# continue
# print(detections_bs[j])
# detections_bs --> [image_id, ymin, xmin, ymax, xmax, score, class]
pts = self.convert_array(detections_bs[j])
img = driver.visualize(raw_images[j], detections_bs[j], **kwargs)
Image.fromarray(img).save(output_image_path)
for pt in pts:
# print(pt)
# if (pts == pt).all(-1).sum() != 1:
# continue
log.write('{},{},{},{},{},{},{},{}\n'.format(
filename, len(pts), pt[1], pt[2], pt[3], pt[4], pt[5], pt[6]))
if len(pts) == 0:
log.write('{},0,-1,-1,-1,-1,-1\n'.format(filename, 0))
print('writing file to %s' % output_image_path)
log.close()
def saved_model_inference(self, image_path_pattern, output_dir,
bbox_crop_margin_ratio, **kwargs):
"""Perform inference for the given saved model."""
driver = inference.ServingDriver(
self.model_name,
self.ckpt_path,
batch_size=self.batch_size,
use_xla=self.use_xla,
model_params=self.model_config.as_dict(),
**kwargs)
driver.load(self.saved_model_dir)
# Serving time batch size should be fixed.
batch_size = self.batch_size or 1
all_files = list(tf.io.gfile.glob(image_path_pattern))
# print('all_files=', all_files)
num_batches = (len(all_files) + batch_size - 1) // batch_size
detected_dir = os.path.join(output_dir, "detected")
no_detected_dir = os.path.join(output_dir, "no_detected")
crop_dir = os.path.join(output_dir, "crop")
os.makedirs(detected_dir, exist_ok=True)
os.makedirs(no_detected_dir, exist_ok=True)
os.makedirs(crop_dir, exist_ok=True)
for i in range(num_batches):
batch_files = all_files[i * batch_size:(i + 1) * batch_size]
height, width = self.model_config.image_size
images = [Image.open(f).convert("RGB") for f in batch_files]
if len(set([m.size for m in images])) > 1:
# Resize only if images in the same batch have different sizes.
images = [m.resize((height, width)) for m in images]
raw_images = [np.array(m) for m in images]
size_before_pad = len(raw_images)
if size_before_pad < batch_size:
padding_size = batch_size - size_before_pad
raw_images += [np.zeros_like(raw_images[0])] * padding_size
detections_bs = driver.serve_images(raw_images)
print(detections_bs)
for j in range(size_before_pad):
if len(detections_bs[j]) == 0:
shutil.copy(batch_files[j], no_detected_dir)
else:
prediction = detections_bs[j]
boxes = prediction[:, 1:5]
classes = prediction[:, 6].astype(int)
scores = prediction[:, 5]
im = Image.open(batch_files[j]).convert("RGB")
w, h = im.size
crop_cnt = 0
for k, box in enumerate(boxes):
if scores[k] < kwargs["min_score_thresh"]:
continue
crop_cnt += 1
if bbox_crop_margin_ratio != 0.0:
bw = box[3] - box[1]
bh = box[2] - box[0]
box[1] = max(
round(box[1] - (bw * bbox_crop_margin_ratio)),
0)
box[3] = min(
round(box[3] + (bw * bbox_crop_margin_ratio)),
w)
box[0] = max(
round(box[0] - (bh * bbox_crop_margin_ratio)),
0)
box[2] = min(
round(box[2] + (bh * bbox_crop_margin_ratio)),
h)
crop_im = im.crop((box[1], box[0], box[3], box[2]))
image_file_name = os.path.splitext(
os.path.basename(batch_files[j]))[0]
target_crop_dir = os.path.join(crop_dir,
str(classes[k]))
os.makedirs(target_crop_dir, exist_ok=True)
output_image_path = os.path.join(
target_crop_dir,
"{}_{}.jpg".format(image_file_name, j))
crop_im.save(output_image_path)
if crop_cnt < 1:
shutil.copy(batch_files[j], no_detected_dir)
continue
img = driver.visualize(raw_images[j], detections_bs[j],
**kwargs)
# img_id = str(i * batch_size + j)
output_image_path = os.path.join(
detected_dir, os.path.basename(batch_files[j]))
Image.fromarray(img).save(output_image_path)
logging.info('writing file to %s', output_image_path)
def export_saved_model(self):
driver = inference.ServingDriver(self.model_name, self.ckpt_path)
driver.build()
driver.export(self.saved_model_dir)
def agnosticCoco(self, input_image, coco_json, **kwargs):
import json
import pickle
from coco_eval import coco_eval
imageAnnotations = json.load(open(coco_json))
evals = {}
driver = inference.ServingDriver(
self.model_name,
self.ckpt_path,
batch_size=self.batch_size,
use_xla=self.use_xla,
model_params=self.model_config.as_dict(),
**kwargs)
driver.load(self.saved_model_dir)
for cat in imageAnnotations['categories']:
id, name = cat['id'], cat['name']
print('Doing', id, name)
image_file_names = [
os.path.join(input_image, img['file_name'])
for img in imageAnnotations['images']
if img['categories'] == [id]
] # for test taking only three images
if not len(image_file_names):
print(id, name, 'have no images')
continue
# Serving time batch size should be fixed.
batch_size = self.batch_size or 1
all_files = image_file_names
print('all_files=', all_files)
num_batches = (len(all_files) + batch_size - 1) // batch_size
results = []
for i in range(num_batches):
batch_files = all_files[i * batch_size:(i + 1) * batch_size]
fnames = [f for f in batch_files]
height, width = self.model_config.image_size
images = [Image.open(f) for f in batch_files]
# if len(set([m.size for m in images])) > 1:
# # Resize only if images in the same batch have different sizes.
# images = [m.resize(height, width) for m in images]
raw_images = [np.array(m) for m in images]
# size_before_pad = len(raw_images)
# if size_before_pad < batch_size:
# padding_size = batch_size - size_before_pad
# raw_images += [np.zeros_like(raw_images[0])] * padding_size
print(fnames)
try:
detections_bs = driver.serve_images(raw_images)
except: ## no detection
detections_bs = []
continue
boxes = detections_bs[0, :, 1:5]
classes = detections_bs[0, :, 6].astype(int)
scores = detections_bs[0, :, 5]
res = dict(file=fnames[0],
height=height,
width=width,
detections=[])
# creating compatible boxes:
for j in range(boxes.shape[0]):
if scores[j] > kwargs['min_score_thresh']:
res['detections'].append(
dict(conf=scores[j],
category=int(classes[j]),
bbox=boxes[j, :]))
results.append(res)
# results = load_and_run_detector_output(model_file=flag.checkpoint_folder,
# image_file_names=image_file_names,
# confidence_threshold=0.4)
if results:
# convertire annotazioni alla buona classe
coco_metrics = coco_eval(results,
coco_json.replace(
'animals', 'animal'),
save=True,
boxTransform='oid')
evals[id] = (name, coco_metrics)
results = {}
with open('out/' + 'evals' + '.pkl', 'wb') as f:
pickle.dump(evals, f, pickle.HIGHEST_PROTOCOL)
print(evals[id])
results = []
def saved_model_inference(self, image_path_pattern, output_dir, **kwargs):
"""Perform inference for the given saved model."""
driver = inference.ServingDriver(
self.model_name,
self.ckpt_path,
batch_size=self.batch_size,
use_xla=self.use_xla,
model_params=self.model_config.as_dict(),
**kwargs)
driver.load(self.saved_model_dir)
# Serving time batch size should be fixed.
batch_size = self.batch_size or 1
all_files = list(tf.io.gfile.glob(image_path_pattern))
num_batches = (len(all_files) + batch_size - 1) // batch_size
for i in tqdm(range(num_batches)):
batch_files = all_files[i * batch_size:(i + 1) * batch_size]
height, width = self.model_config.image_size
images = []
img_path = []
for f in batch_files:
images.append(Image.open(f))
img_path.append(f)
if len(set([m.size for m in images])) > 1:
# Resize only if images in the same batch have different sizes.
images = [m.resize(height, width) for m in images]
raw_images = [np.array(m) for m in images]
size_before_pad = len(raw_images)
if size_before_pad < batch_size:
padding_size = batch_size - size_before_pad
raw_images += [np.zeros_like(raw_images[0])] * padding_size
detections_bs = driver.serve_images(raw_images)
for j in range(size_before_pad):
img = driver.visualize(raw_images[j], detections_bs[j],
**kwargs)
img_id = str(i * batch_size + j)
image_file_name = os.path.basename(img_path[j])
folder_name = os.path.basename(os.path.dirname(img_path[j]))
output_image_path = os.path.join(output_dir, 'png',
folder_name, image_file_name)
output_image_path1 = os.path.join(output_dir, 'png',
folder_name)
#print(image_file_name)
boxes = detections_bs[j][:, 1:5]
classes = detections_bs[j][:, 6].astype(int)
scores = detections_bs[j][:, 5]
box_path = output_dir + "/boxes"
img_box_name = image_file_name[:image_file_name.rindex('.')]
if not os.path.exists(box_path):
os.makedirs(box_path)
with open(os.path.join(box_path, img_box_name) + '.txt',
'a') as box_log:
for iy, x in enumerate(detections_bs[j]):
if x[5] > kwargs.get('min_score_thresh'):
boxstr = ''
boxstr += str(x[5]) #confident
boxstr += ' ' + str(x[1:5][1])
boxstr += ' ' + str(x[1:5][0])
boxstr += ' ' + str(x[1:5][3])
boxstr += ' ' + str(x[1:5][2])
box_log.write('tumor ' + boxstr + '\n')
if not os.path.exists(output_image_path1):
os.makedirs(output_image_path1)
#print(output_image_path1)
Image.fromarray(img).save(output_image_path)