def build_data_parallel_model(model, single_gpu_build_func):
"""Build a data parallel model given a function that builds the model on a
single GPU.
"""
if model.only_build_forward_pass:
single_gpu_build_func(model)
elif model.train:
all_loss_gradients = _build_forward_graph(model, single_gpu_build_func)
# Add backward pass on all GPUs
# 添加反向传播操作
model.AddGradientOperators(all_loss_gradients)
if cfg.NUM_GPUS > 1:
_add_allreduce_graph(model)
for gpu_id in range(cfg.NUM_GPUS):
# After allreduce, all GPUs perform SGD updates on their identical
# params and gradients in parallel
# 添加参数更新操作
with c2_utils.NamedCudaScope(gpu_id):
add_single_gpu_param_update_ops(model, gpu_id)
else:
# Test-time network operates on single GPU
# Test-time parallelism is implemented through multiprocessing
with c2_utils.NamedCudaScope(model.target_gpu_id):
single_gpu_build_func(model)
def run_model_cfg(args, im, check_blobs):
workspace.ResetWorkspace()
model, _ = load_model(args)
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = test_engine.im_detect_all(
model, im, None, None,
)
boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format(
cls_boxes, cls_segms, cls_keyps)
# sort the results based on score for comparision
boxes, segms, keypoints, classes = _sort_results(
boxes, segms, keypoints, classes)
# write final results back to workspace
def _ornone(res):
return np.array(res) if res is not None else np.array([], dtype=np.float32)
with c2_utils.NamedCudaScope(0):
workspace.FeedBlob(core.ScopedName('result_boxes'), _ornone(boxes))
workspace.FeedBlob(core.ScopedName('result_segms'), _ornone(segms))
workspace.FeedBlob(core.ScopedName('result_keypoints'), _ornone(keypoints))
workspace.FeedBlob(core.ScopedName('result_classids'), _ornone(classes))
# get result blobs
with c2_utils.NamedCudaScope(0):
ret = _get_result_blobs(check_blobs)
return ret
def build_data_parallel_model(model, single_gpu_build_func):
"""Build a data parallel model given a function that builds the model on a
single GPU.
"""
if model.only_build_forward_pass:
single_gpu_build_func(model)
elif model.train:
all_loss_gradients = _build_forward_graph(model, single_gpu_build_func)
# Add backward pass on all GPUs
grad_map = model.AddGradientOperators(all_loss_gradients)
#if cfg.CLIP:
# keys = []
# for key in model.TrainableParams():
# k = str(key)
# if 'bbox_pred_std' in k:
# keys.append(k)
# if 'bbox_pred_phi' in k:
# keys.append(k)
# #bbox_pred_fpn
# #if 'bbox_pred' in k:
# # keys.append(k)
# #grad_map_for_param = {key: grad_map[key] for key in keys}
# grad_map_for_param = {str(key): grad_map[str(key)] for key in model.TrainableParams()}
# net_modifier = GradientClipping(
# grad_clip_method='by_value',
# clip_max=1.,
# clip_min=-1.,
# #blobs_to_include=None,
# )
# #net_modifier = GradientClipping(
# # grad_clip_method='by_norm',
# # clip_norm_type='l2_norm',
# # clip_threshold=0.1,
# # #blobs_to_include=None,
# #)
# net_modifier(model.net, grad_map=grad_map_for_param)
if cfg.NUM_GPUS > 1:
_add_allreduce_graph(model)
for gpu_id in range(cfg.NUM_GPUS):
# After allreduce, all GPUs perform SGD updates on their identical
# params and gradients in parallel
with c2_utils.NamedCudaScope(gpu_id):
add_single_gpu_param_update_ops(model, gpu_id)
else:
# Test-time network operates on single GPU
# Test-time parallelism is implemented through multiprocessing
with c2_utils.NamedCudaScope(model.target_gpu_id):
single_gpu_build_func(model)
def __getitem__(self, idx):
im_name = 'DensePoseData/demo_data/xyz.jpg'
output_dir = 'DensePoseData/'
img_name1 = os.path.join(self.root_dir1, self.landmarks_frame.iloc[idx,
0])
image1 = cv2.imread(img_name1)
img_name2 = os.path.join(self.root_dir2, self.landmarks_frame.iloc[idx,
1])
image2 = cv2.imread(img_name2)
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all(
self.model, image1, None, timers=self.timers)
im1 = vis_utils.vis_one_image(
image1[:, :, ::-1], # BGR -> RGB for visualization
im_name,
output_dir,
cls_boxes,
cls_segms,
cls_keyps,
cls_bodys,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2)
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all(
self.model, image2, None, timers=self.timers)
im2 = vis_utils.vis_one_image(
image2[:, :, ::-1], # BGR -> RGB for visualization
im_name,
output_dir,
cls_boxes,
cls_segms,
cls_keyps,
cls_bodys,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2)
image3 = cv2.merge((image1, im1, im2))
sample = {'image1': image1, 'image2': image2, 'image3': image3}
if self.transform:
sample = self.transform(sample)
return sample
def detect(self, frame):
timers = defaultdict(Timer)
mask_frame = frame
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
self.model, mask_frame, None, timers=timers)
# verifica se a imagem deve ser descartada
boxes, sgms, keypts, classes = vis_utils.convert_from_cls_format(
cls_boxes, cls_segms, cls_keyps)
bbox_list = []
if len(boxes) > 0:
indexes_big = box_utils.filter_big_boxes(boxes, 300)
indexes_small = box_utils.filter_small_boxes(boxes, 100)
for i in range(len(boxes)):
if (i in indexes_big and i in indexes_small):
if classes[i] in [1, 2, 3] and boxes[i, 4] > 0.7:
box = boxes[i]
bbox_list.append([
int(box[0]),
int(box[1]),
int(box[2]) - int(box[0]),
int(box[3]) - int(box[1])
], classes[i])
# mask_frame = vis_utils.vis_one_image_opencv(mask_frame, cls_boxes, cls_segms, cls_keyps, thresh=0.8, kp_thresh=2,
# show_box=True, dataset=CocoNames, show_class=True) #, hiden_indexes=True, indexes_shown=[1])
return bbox_list
def hanle_frame(args, frameId, im, logger, model, dataset):
#out_name = os.path.join(
# args.output_dir, '{}'.format(frameId + '.pdf')
#)
logger.info('Processing frame: {}'.format(frameId))
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, None, timers=timers)
logger.info('Inference time: {:.3f}s'.format(time.time() - t))
for k, v in timers.items():
logger.info(' | {}: {:.3f}s'.format(k, v.average_time))
if frameId == 1:
logger.info(
' \ Note: inference on the first image will be slower than the '
'rest (caches and auto-tuning need to warm up)')
vis_utils.vis_one_image(
im[:, :, ::-1], # BGR -> RGB for visualization
'{}'.format(frameId),
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2)
def extract_iuv(image_path, model, infer_engine):
im = cv2.imread(image_path)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all(
model, im, None
)
iuv_out = vis_utils.vis_one_image(
im[:, :, ::-1], # BGR -> RGB for visualization
None,
None,
cls_boxes,
cls_segms,
cls_keyps,
cls_bodys,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2
)
return iuv_out
def process_images(
args_weights,
args_im_or_folder,
args_image_ext
):
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
model = infer_engine.initialize_model_from_cfg(args_weights)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
if os.path.isdir(args_im_or_folder):
im_list = glob.iglob(args_im_or_folder + '/*.' + args_image_ext)
else:
im_list = [args_im_or_folder]
for i, im_name in enumerate(im_list):
im = cv2.imread(im_name)
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, None, timers=timers
)
boxes, segms, keyps, classes = vis_utils.convert_from_cls_format(cls_boxes, cls_segms, cls_keyps)
if classes is not None:
class_strs = [dummy_coco_dataset.classes[c] for c in classes]
im_name = im_name.split('/')[-1].split('.'+args_image_ext)[0]
yield im_name, boxes, segms, class_strs, im.shape[:2]
def process_image(input_file, output_file):
#image = stringToImage(input_img[input_img.find(",")+1:])
#img = cv2.imread('stylegan/narrow/13.test.jpg')
#img = cv2.imread('stylegan/curated/231.jpg')
img = cv2.imread(input_file)
#img = toRGB(image)
#logger.info(input_file)
timers = defaultdict(Timer)
t = time.time()
size = img.shape[:2]
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all(
model, img, None, timers=timers)
t2 = time.time()
#logger.info('Inference time: {:.3f}s'.format(t2 - t))
if cls_bodys is not None:
(final, num_people) = process_bodies(img, cls_boxes, cls_bodys)
if final is not None:
if num_people > 4:
output_file = output_file + 'X.jpg'
else:
output_file = output_file + '.jpg'
cv2.imwrite(output_file, final)
return True
else:
#print('Skipping')
return False
else:
#print('Skipping')
return False
def main(input_img, with_pix2pix=False):
image = stringToImage(input_img[input_img.find(",") + 1:])
img = toRGB(image)
logger.info('Processing {} -> {}'.format('New Image', 'Output...'))
timers = defaultdict(Timer)
t = time.time()
size = img.shape[:2]
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all(
model, img, None, timers=timers)
for key, timer in timers.items():
print(key, timer.total_time)
t2 = time.time()
r = vis_one_image(img,
'testImage',
output_dir,
cls_boxes,
cls_segms,
cls_keyps,
cls_bodys,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2)
t3 = time.time()
if with_pix2pix:
r = requests.post(pix2pixURL, data={'data': r})
logger.info('Inference time: {:.3f}s'.format(t2 - t))
logger.info('Visualization time: {:.3f}s'.format(t3 - t2))
logger.info('Pix2pix time: {:.3f}s'.format(time.time() - t3))
return r
def generate_predicitions_from_frames(images, config_file, weights):
"""Generator yields inferred boxes and keypoints for each image in a provided iterable of images
Args:
images: iterable images
config_file: Detectron configuration file
weights: pretrained weights
Returns:
yields i, im, cls_boxes, cls_segms, cls_keyps
"""
logger = logging.getLogger(__name__)
merge_cfg_from_file(config_file)
cfg.NUM_GPUS = 1
weights = cache_url(weights, cfg.DOWNLOAD_CACHE)
assert_and_infer_cfg(cache_urls=False)
model = infer_engine.initialize_model_from_cfg(weights)
for i, im in enumerate(images):
logger.info("Processing frame {}".format(i))
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, None, timers=timers
)
logger.info("Inference time: {:.3f}s".format(time.time() - t))
for k, v in timers.items():
logger.info(" | {}: {:.3f}s".format(k, v.average_time))
if i == 0:
logger.info(
"Note: inference on the first image will be slower than the "
"rest (caches and auto-tuning need to warm up)"
)
yield i, im, cls_boxes, cls_segms, cls_keyps
def infer(self, im, thresh=0.5):
ts = time.time()
timers = defaultdict(Timer)
with c2_utils.NamedCudaScope(self.gpu_id):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
self.__model, im, None, timers=timers)
te = time.time()
print('det time:', te - ts)
for k, v in timers.items():
print(' | {}: {:.3f}s'.format(k, v.average_time))
if isinstance(cls_boxes, list):
boxes, segms, keypoints, classes = cvt_cls(cls_boxes, cls_segms,
cls_keyps)
if boxes is None or boxes.shape[0] == 0 or max(boxes[:, 4]) < thresh:
return None
heads = list()
for i in range(len(boxes)):
bbox = boxes[i, :4]
score = boxes[i, -1]
if score < thresh:
continue
heads.append([int(x) for x in bbox] + [float(score)])
return heads
def main(args):
logger = logging.getLogger(__name__)
merge_cfg_from_file(args.cfg)
cfg.TEST.WEIGHTS = args.weights
cfg.NUM_GPUS = 1
assert_and_infer_cfg()
model = infer_engine.initialize_model_from_cfg(args.weights)
dummy_dataset = dummy_datasets.get_coco_dataset()
if os.path.isdir(args.im_or_folder):
im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext)
else:
im_list = [args.im_or_folder]
for i, im_name in enumerate(im_list):
logger.info('Processing {}'.format(im_name))
im = cv2.imread(im_name)
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_scores, _, _ = infer_engine.im_detect_all(model,
im,
None,
timers=timers)
logger.info('Inference time: {:.3f}s'.format(time.time() - t))
cl = np.argmax(cls_scores)
for k, v in timers.items():
logger.info(' | {}: {:.3f}s'.format(k, v.average_time))
logger.info(' | Class is: {}'.format(dummy_dataset.classes[cl]))
logger.info(' | Class Confidance is: {:.2f}%'.format(
cls_scores[cl] * 100))
if i == 0:
logger.info(
' \ Note: inference on the first image will be slower than the '
'rest (caches and auto-tuning need to warm up)')
def process_image(input_image, num_of_people, num_of_permutations):
timers = defaultdict(Timer)
t = time.time()
image = stringToImage(input_image[input_image.find(",")+1:])
img = toRGB(image)
size = img.shape[:2]
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all(
model, img, None, timers=timers
)
t2 = time.time()
#logger.info('Inference time: {:.3f}s'.format(t2 - t))
jpgs = []
if cls_bodys is not None:
(finals,num_people) = process_bodies(img, cls_boxes, cls_bodys, num_of_people, num_of_permutations)
logger.info('Num of people {}'.format(num_people))
if len(finals) > 0:
for final in finals:
retval, buffer = cv2.imencode('.jpg', final)
jpg_as_text = base64.b64encode(buffer)
jpgs.append(jpg_as_text)
else:
print('Skipping')
else:
print('Skipping')
return jpgs
def add_training_inputs(model, roidb=None):
"""Create network input ops and blobs used for training. To be called
*after* model_builder.create().
"""
# Implementation notes:
# Typically, one would create the input ops and then the rest of the net.
# However, creating the input ops depends on loading the dataset, which
# can take a few minutes for COCO.
# We prefer to avoid waiting so debugging can fail fast.
# Thus, we create the net *without input ops* prior to loading the
# dataset, and then add the input ops after loading the dataset.
# Since we defer input op creation, we need to do a little bit of surgery
# to place the input ops at the start of the network op list.
assert model.train, 'Training inputs can only be added to a trainable model'
if roidb is not None:
# To make debugging easier you can set cfg.DATA_LOADER.NUM_THREADS = 1
model.roi_data_loader = RoIDataLoader(
roidb,
num_loaders=cfg.DATA_LOADER.NUM_THREADS,
minibatch_queue_size=cfg.DATA_LOADER.MINIBATCH_QUEUE_SIZE,
blobs_queue_capacity=cfg.DATA_LOADER.BLOBS_QUEUE_CAPACITY)
orig_num_op = len(model.net._net.op)
blob_names = roi_data_minibatch.get_minibatch_blob_names(is_training=True)
for gpu_id in range(cfg.NUM_GPUS):
with c2_utils.NamedCudaScope(gpu_id):
for blob_name in blob_names:
workspace.CreateBlob(core.ScopedName(blob_name))
model.net.DequeueBlobs(model.roi_data_loader._blobs_queue_name,
blob_names)
# A little op surgery to move input ops to the start of the net
diff = len(model.net._net.op) - orig_num_op
new_op = model.net._net.op[-diff:] + model.net._net.op[:-diff]
del model.net._net.op[:]
model.net._net.op.extend(new_op)
def extract_person(image, background_image, model, dataset):
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, image, None, timers=timers)
boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format(
cls_boxes,
cls_segms,
cls_keyps,
)
masks = mask_util.decode(segms)
masks = np.moveaxis(masks, 2, 0)
output_image = np.copy(background_image)
for box, mask, c, in zip(boxes, masks, classes):
score = box[-1]
if score < 0.9:
continue
if dataset.classes[c] != 'person':
continue
idx = np.where(mask != 0)
output_image[idx[0], idx[1], :] = image[idx[0], idx[1], :]
return output_image
def main(input_img):
image = stringToImage(input_img[input_img.find(",") + 1:])
img = toRGB(image)
logger.info('Processing {} -> {}'.format('New Image', 'Output...'))
timers = defaultdict(Timer)
t = time.time()
size = img.shape[:2]
#img = imresize(img, (320, 240), interp='bilinear')
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all(
model, img, None, timers=timers)
for key, timer in timers.items():
print(key, timer.total_time)
t2 = time.time()
densepose_img = vis_one_image(img,
'testImage',
output_dir,
cls_boxes,
cls_segms,
cls_keyps,
cls_bodys,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2)
logger.info('Inference time: {:.3f}s'.format(t2 - t))
return densepose_img
def single_process(args, dummy_coco_dataset, im, im_name, model):
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, None, timers=timers)
logger.info('Inference time: {:.3f}s'.format(time.time() - t))
for k, v in timers.items():
logger.info(' | {}: {:.3f}s'.format(k, v.average_time))
# if i == 0:
# logger.info(
# ' \ Note: inference on the first image will be slower than the '
# 'rest (caches and auto-tuning need to warm up)'
# )
print("预测结果：", cls_boxes, cls_segms, cls_keyps)
new_img = vis_utils.vis_one_image(
im[:, :, ::-1], # BGR -> RGB for visualization
im_name,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=args.thresh,
kp_thresh=args.kp_thresh,
ext=args.output_ext,
out_when_no_box=args.out_when_no_box)
return new_img
def test_net(weights_file, dataset_name, ind_range=None, gpu_id=0):
roidb, dataset, start_ind, end_ind, total_num_images = get_roidb_and_dataset(
dataset_name, ind_range)
model = initialize_model_from_cfg(weights_file, gpu_id=gpu_id)
num_images = len(roidb)
num_classes = cfg.MODEL.NUM_CLASSES
all_boxes = empty_results(num_classes, num_images)
timers = defaultdict(Timer)
result = {}
for i, entry in enumerate(roidb):
box_proposals = None
im = cv2.imread(entry['image'])
# print(entry['image'])
# im_name = os.path.splitext(os.path.basename(entry['image']))[0]
im_result = {}
im_result['fileName'] = entry['file_name']
im_result['imageId'] = str(entry['id'])
# print(entry['file_name'])
with c2_utils.NamedCudaScope(gpu_id):
cls_boxes_i, uc = im_detect_all(model, im, box_proposals, timers)
entry['entropy'] = uc
# print(uc)
# entry['result'] = cls_boxes_i
# entropy.append(entropy_i)
## all_boxes
cls_box_result = {}
for cls_idx in range(1, len(cls_boxes_i)):
if (len(cls_boxes_i[cls_idx])) == 0:
continue
cls_box_result[str(cls_idx)] = []
for box_idx in cls_boxes_i[cls_idx]:
box_i = {}
box_i['x'] = int(box_idx[0])
box_i['y'] = int(box_idx[1])
box_i['w'] = int(box_idx[2] - box_idx[0])
box_i['h'] = int(box_idx[3] - box_idx[1])
box_i['score'] = float(box_idx[4])
cls_box_result[str(cls_idx)].append(box_i)
extend_results(i, all_boxes, cls_boxes_i)
im_result['annotation'] = cls_box_result
im_result['uncertainty'] = entry['entropy']
result[str(im_result['imageId'])] = im_result
if i % 10 == 0: # Reduce log file size
ave_total_time = np.sum([t.average_time for t in timers.values()])
eta_seconds = ave_total_time * (num_images - i - 1)
eta = str(datetime.timedelta(seconds=int(eta_seconds)))
det_time = (timers['im_detect_bbox'].average_time +
timers['im_detect_mask'].average_time +
timers['im_detect_keypoints'].average_time)
misc_time = (timers['misc_bbox'].average_time +
timers['misc_mask'].average_time +
timers['misc_keypoints'].average_time)
logger.info(('im_detect: range [{:d}, {:d}] of {:d}: '
'{:d}/{:d} {:.3f}s + {:.3f}s (eta: {})').format(
start_ind + 1, end_ind, total_num_images,
start_ind + i + 1, start_ind + num_images,
det_time, misc_time, eta))
print(result)
return roidb, result
def create(model_type_func, train=False, gpu_id=0):
"""Generic model creation function that dispatches to specific model
building functions.
By default, this function will generate a data parallel model configured to
run on cfg.NUM_GPUS devices. However, you can restrict it to build a model
targeted to a specific GPU by specifying gpu_id. This is used by
optimizer.build_data_parallel_model() during test time.
"""
model = DetectionModelHelper(
name=model_type_func,
train=train,
num_classes=cfg.MODEL.NUM_CLASSES,
init_params=(train or cfg.VIS_NET)
)
model.only_build_forward_pass = False
model.target_gpu_id = gpu_id
model = get_func(model_type_func)(model)
# Stop gradient at specified nodes
if len(cfg.TRAIN.FREEZE_BLOBS):
blob_references = []
for gpu_id in range(cfg.NUM_GPUS):
with c2_utils.NamedCudaScope(gpu_id):
for blob_name in cfg.TRAIN.FREEZE_BLOBS:
try:
blob_references.append(model.net.GetBlobRef(core.ScopedName(blob_name)))
except KeyError, e:
logger.warn('Failed to freeze blob. {}'.format(e))
if not cfg.CONTINUE_ON_ERROR:
raise
for blob_ref in blob_references:
logger.info('Freezing blob. {}'.format(blob_ref))
model.StopGradient(blob_ref, blob_ref)
def main(args):
logger = logging.getLogger(__name__)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
cfg_orig = load_cfg(envu.yaml_dump(cfg))
im = cv2.imread(args.im_file)
if args.rpn_pkl is not None:
proposal_boxes, _proposal_scores = get_rpn_box_proposals(im, args)
workspace.ResetWorkspace()
else:
proposal_boxes = None
cls_boxes, cls_segms, cls_keyps, cls_bodys = None, None, None, None
for i in range(0, len(args.models_to_run), 2):
pkl = args.models_to_run[i]
yml = args.models_to_run[i + 1]
cfg.immutable(False)
merge_cfg_from_cfg(cfg_orig)
merge_cfg_from_file(yml)
if len(pkl) > 0:
weights_file = pkl
else:
weights_file = cfg.TEST.WEIGHTS
cfg.NUM_GPUS = 1
assert_and_infer_cfg(cache_urls=False)
model = model_engine.initialize_model_from_cfg(weights_file)
with c2_utils.NamedCudaScope(0):
cls_boxes_, cls_segms_, cls_keyps_ , cls_bodys_= \
model_engine.im_detect_all(model, im, proposal_boxes)
cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes
cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms
cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps
cls_bodys = cls_bodys_ if cls_bodys_ is not None else cls_bodys
workspace.ResetWorkspace()
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(args.im_file) + '.pdf'))
logger.info('Processing {} -> {}'.format(args.im_file, out_name))
with open('test_vis.pkl', 'w') as f:
pickle.dump(
{
'im': im,
'cls_boxes': np.array(cls_boxes),
'cls_bodys': np.array(cls_bodys)
}, f)
vis_utils.vis_one_image(im[:, :, ::-1],
args.im_file,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
cls_bodys,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2)
def getKptByModel(self, image, thresh=0.7):
top_labels = []
top_xmin = []
top_ymin = []
top_xmax = []
top_ymax = []
top_scores = []
timers = defaultdict(Timer)
# with c2_utils.NamedCudaScope(0):
# cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
# self.model, image, None, timers=timers
# )
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
self.model, image, None, timers=timers)
# boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format(cls_boxes, cls_segms, cls_keyps)
image = vis_utils.vis_one_image_opencv(image,
cls_boxes,
cls_segms,
cls_keyps,
dataset=None,
show_class=True,
thresh=0.7,
kp_thresh=2)
# try:
# print (keypoints)
# except:
# pass
return image
def get_detections_from_im(cfg, model, im, image_id, feat_blob_name,
MIN_BOXES, MAX_BOXES, conf_thresh=0.2, bboxes=None):
with c2_utils.NamedCudaScope(0):
scores, cls_boxes, im_scale = infer_engine.im_detect_bbox(model,
im,
cfg.TEST.SCALE,
cfg.TEST.MAX_SIZE,
boxes=bboxes)
feat_map = workspace.FetchBlob("gpu_0/res5_2_branch2c")
box_features = workspace.FetchBlob(feat_blob_name)
cls_prob = workspace.FetchBlob("gpu_0/cls_prob")
rois = workspace.FetchBlob("gpu_0/rois")
max_conf = np.zeros((rois.shape[0]))
# unscale back to raw image space
cls_boxes = rois[:, 1:5] / im_scale
for cls_ind in range(1, cls_prob.shape[1]):
cls_scores = scores[:, cls_ind]
dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)
keep = np.array(nms(dets, cfg.TEST.NMS))
max_conf[keep] = np.where(cls_scores[keep] > max_conf[keep], cls_scores[keep], max_conf[keep])
keep_boxes = np.where(max_conf >= conf_thresh)[0]
if len(keep_boxes) < MIN_BOXES:
keep_boxes = np.argsort(max_conf)[::-1][:MIN_BOXES]
elif len(keep_boxes) > MAX_BOXES:
keep_boxes = np.argsort(max_conf)[::-1][:MAX_BOXES]
objects = np.argmax(cls_prob[keep_boxes], axis=1)
img_shape = [np.size(im, 0), np.size(im, 1)]
return feat_map, box_features[keep_boxes], cls_boxes[keep_boxes], np.array(img_shape)
def find_optimal_bars(image_directory, layer):
model = get_model()
im_list = glob.iglob(image_directory + '/*.jpg')
im_list = [x for x in im_list] # so we can get length
max_sd_per_map = [None] * len(im_list)
for i, im_name in enumerate(im_list):
print('processing {}'.format(im_name))
im = cv2.imread(im_name)
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, None, timers=None)
responses = workspace.blobs['gpu_0/{}'.format(layer)]
sd = []
for i in range(responses.shape[0]):
sd.append(np.std(responses[i, :, :, :]))
max_sd_across_boxes = responses[np.argmax(sd), :, :, :]
# stimuli aren't processed in order, so get index from file name
bar_name = os.path.basename(im_name)[3:-4]
bar_num = int(bar_name)
max_sd_per_map[bar_num] = np.max(np.max(max_sd_across_boxes,
axis=-1),
axis=-1)
max_sd_per_map = np.array(max_sd_per_map)
result = np.argmax(max_sd_per_map, axis=0)
print result # TODO: check this
return result
def main(args):
logger = logging.getLogger(__name__)
merge_cfg_from_file(args.cfg)
cfg.NUM_GPUS = 1
args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE)
assert_and_infer_cfg(cache_urls=False)
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
model = infer_engine.initialize_model_from_cfg(args.weights)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
if os.path.isdir(args.im_or_folder):
im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext)
else:
im_list = [args.im_or_folder]
for i, im_name in enumerate(im_list):
output_image_dir = os.path.join(args.output_dir, 'images')
out_name = os.path.join(
output_image_dir,
'{}'.format(os.path.basename(im_name) + '.' + args.output_ext))
logger.info('Processing {} -> {}'.format(im_name, out_name))
im = cv2.imread(im_name)
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, None, timers=timers)
logger.info('Inference time: {:.3f}s'.format(time.time() - t))
for k, v in timers.items():
logger.info(' | {}: {:.3f}s'.format(k, v.average_time))
if i == 0:
logger.info(
' \ Note: inference on the first image will be slower than the '
'rest (caches and auto-tuning need to warm up)')
# vis_utils.vis_one_image(
# im[:, :, ::-1], # BGR -> RGB for visualization
# im_name,
# output_image_dir,
# cls_boxes,
# cls_segms,
# cls_keyps,
# dataset=dummy_coco_dataset,
# box_alpha=0.3,
# show_class=True,
# thresh=0.7,
# kp_thresh=2,
# ext=args.output_ext,
# out_when_no_box=args.out_when_no_box
#)
_write_to_txt(cls_boxes, cls_segms, cls_keyps, im_name,
dummy_coco_dataset)
def _build_forward_graph(model, single_gpu_build_func):
"""Construct the forward graph on each GPU."""
all_loss_gradients = {} # Will include loss gradients from all GPUs
# Build the model on each GPU with correct name and device scoping
for gpu_id in range(cfg.NUM_GPUS):
with c2_utils.NamedCudaScope(gpu_id):
all_loss_gradients.update(single_gpu_build_func(model))
return all_loss_gradients
def main(args):
logger = logging.getLogger(__name__)
dummy_nucoco_dataset = dummy_datasets.get_nucoco_dataset()
cfg_orig = load_cfg(envu.yaml_dump(cfg))
## Load image
coco = COCO_PLUS(args.ann_file, args.imgs_dir)
image_id = coco.dataset['images'][args.im_ind]['id']
img_path = os.path.join(args.imgs_dir, coco.imgs[image_id]["file_name"])
im = cv2.imread(img_path)
## Get the proposals for this image
proposals = rrpn_loader(args.rpn_pkl)
proposal_boxes = proposals[image_id]['boxes']
_proposal_scores = proposals[image_id]['scores']
workspace.ResetWorkspace()
## run models
cls_boxes, cls_segms, cls_keyps = None, None, None
for i in range(0, len(args.models_to_run), 2):
pkl = args.models_to_run[i]
yml = args.models_to_run[i + 1]
cfg.immutable(False)
merge_cfg_from_cfg(cfg_orig)
merge_cfg_from_file(yml)
if len(pkl) > 0:
weights_file = pkl
else:
weights_file = cfg.TEST.WEIGHTS
cfg.NUM_GPUS = 1
assert_and_infer_cfg(cache_urls=False)
model = model_engine.initialize_model_from_cfg(weights_file)
with c2_utils.NamedCudaScope(0):
cls_boxes_, cls_segms_, cls_keyps_ = \
model_engine.im_detect_all(model, im, proposal_boxes)
cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes
cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms
cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps
workspace.ResetWorkspace()
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(img_path) + '.pdf')
)
logger.info('Processing {} -> {}'.format(img_path, out_name))
vis_utils.vis_one_image(
im[:, :, ::-1],
img_path,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_nucoco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2
)
def main(args):
logger = logging.getLogger(__name__)
merge_cfg_from_file(args.cfg)
cfg.NUM_GPUS = 1
args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE)
assert_and_infer_cfg(cache_urls=False)
model = infer_engine.initialize_model_from_cfg(args.weights)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
submit_result = []
result_file_name = 'detectron_val_result.txt'
if os.path.isdir(args.im_or_folder):
im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext)
else:
im_list = [args.im_or_folder]
for i, im_name in enumerate(im_list):
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf'))
logger.info('Processing {} -> {}'.format(im_name, out_name))
im = cv2.imread(im_name)
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, None, timers=timers)
logger.info('Inference time: {:.3f}s'.format(time.time() - t))
for k, v in timers.items():
logger.info(' | {}: {:.3f}s'.format(k, v.average_time))
if i == 0:
logger.info(
' \ Note: inference on the first image will be slower than the '
'rest (caches and auto-tuning need to warm up)')
result = vis_utils.vis_one_image_bbox(
im[:, :, ::-1], # BGR -> RGB for visualization
im_name,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2)
if result:
submit_result.extend(result)
logger.info('Image {}.'.format(i))
# Write file
with open(result_file_name, 'wb') as result_file:
for item in submit_result:
result_file.write("%s\n" % item)
logger.info(
'The result file has been written in {}.'.format(result_file_name))
def main(args):
#logger = logging.getLogger(__name__)
merge_cfg_from_file(args.cfg)
cfg.NUM_GPUS = 1
args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE)
assert_and_infer_cfg(cache_urls=False)
model = infer_engine.initialize_model_from_cfg(args.weights)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
cam = cv2.VideoCapture(0)
# Set Texture
Tex_Atlas = cv2.imread(
'DensePoseData/demo_data/texture_from_SURREAL.png')[:, :, ::-1] / 255.0
#Tex_Atlas = cv2.imread('DensePoseData/demo_data/texture_atlas_200.png')[:,:,::-1]
TextureIm = np.zeros([24, 200, 200, 3])
#
for i in range(4):
for j in range(6):
TextureIm[(6 * i +
j), :, :, :] = Tex_Atlas[(200 * j):(200 * j + 200),
(200 * i):(200 * i + 200), :]
while True:
if cv2.waitKey(1) & 0xFF == ord('q'):
break
retval, im = cam.read()
#imsmall = cv2.resize(im, None, fx=0.5, fy=0.5)
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all(
model, im, None, timers=None)
iuvout, indsout = vis_utils.vis_webcam(im,
cls_boxes,
cls_segms,
cls_keyps,
cls_bodys,
thresh=0.9,
kp_thresh=2,
dataset=dummy_coco_dataset,
show_class=True)
iuvout, indsout = vis_utils.vis_webcam(
im,
boxes=cls_boxes,
segms=cls_segms,
keypoints=cls_keyps,
body_uv=cls_bodys,
thresh=0.9,
kp_thresh=2,
dpi=200,
box_alpha=0.3,
dataset=dummy_coco_dataset,
show_class=True,
)
#cv2.imshow('input', im)
texout = TransferTexturePure(TextureIm, im, iuvout)
cv2.imshow('output', texout)
def main(args):
logger = logging.getLogger(__name__)
merge_cfg_from_file(args.cfg)
cfg.NUM_GPUS = 4
args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE)
assert_and_infer_cfg(cache_urls=False)
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
model = infer_engine.initialize_model_from_cfg(args.weights)
# model = infer_engine.initialize_model_from_cfg(args.weights,gpu_id=3)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
if os.path.isdir(args.im_or_folder):
im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext)
else:
im_list = [args.im_or_folder]
len_str = str(len(os.listdir(args.im_or_folder)))
for i, im_name in enumerate(im_list):
print('~~~~~~~~~~~~~~~~~' + str(i) + '/' + len_str +
"~~~~~~~~~~~~~~~~~~~~~")
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(im_name) + '.jpg'))
logger.info('Processing {} -> {}'.format(im_name, out_name))
im = cv2.imread(im_name)
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( #此处输出的cls_boxes包含类别信息
model, im, None, timers=timers)
logger.info('Inference time: {:.3f}s'.format(time.time() - t))
for k, v in timers.items():
logger.info(' | {}: {:.3f}s'.format(k, v.average_time))
if i == 0:
logger.info(
' \ Note: inference on the first image will be slower than the '
'rest (caches and auto-tuning need to warm up)')
# ipdb.set_trace()
# print(cls_boxes)
# print(cls_segms)
# print(cls_keyps)
vis_utils.vis_one_image(
im[:, :, ::-1], # BGR -> RGB for visualization
im_name,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.5,
kp_thresh=2,
ext='jpg')
