def __init__(self, cfg):
self.cfg = cfg.clone() # cfg can be modified by model
self.model = build_model(self.cfg)
self.model.eval()
self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0])
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.transform_gen = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST
)
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def build_sem_seg_train_aug(cfg):
augs = [
T.ResizeShortestEdge(cfg.INPUT.MIN_SIZE_TRAIN,
cfg.INPUT.MAX_SIZE_TRAIN,
cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING)
]
if cfg.INPUT.CROP.ENABLED:
augs.append(
T.RandomCrop_CategoryAreaConstraint(
cfg.INPUT.CROP.TYPE,
cfg.INPUT.CROP.SIZE,
cfg.INPUT.CROP.SINGLE_CATEGORY_MAX_AREA,
cfg.MODEL.SEM_SEG_HEAD.IGNORE_VALUE,
))
augs.append(T.RandomFlip())
return augs
def __init__(self, cfg, is_train=True):
if cfg.INPUT.CROP.ENABLED and is_train:
self.crop_gen = [
T.ResizeShortestEdge([400, 500, 600], sample_style="choice"),
T.RandomCrop(cfg.INPUT.CROP.TYPE, cfg.INPUT.CROP.SIZE),
]
else:
self.crop_gen = None
self.tfm_gens = build_transform_gen(cfg, is_train)
logging.getLogger(__name__).info(
"Full TransformGens used in training: {}, crop: {}".format(
str(self.tfm_gens), str(self.crop_gen)))
self.img_format = cfg.INPUT.FORMAT
self.is_train = is_train
def build_train_loader1(cls, cfg: CfgNode, mapper=None):
if mapper is None:
mapper = DatasetMapper(
cfg=cfg,
is_train=True,
augmentations=[
T.ResizeShortestEdge(
cfg.INPUT.MIN_SIZE_TRAIN,
cfg.INPUT.MAX_SIZE_TRAIN,
cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING,
),
T.RandomCrop(cfg.INPUT.CROP.TYPE, cfg.INPUT.CROP.SIZE),
T.RandomFlip(),
],
)
return build_detection_train_loader(cfg, mapper=mapper)
def __init__(self, cfg):
self.aug = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST],
cfg.INPUT.MAX_SIZE_TEST)
with open(os.path.join(cfg.ANNO_DIR, cfg.SPLIT + '_anno.json'),
'r') as f:
json_data = json.load(f)
vids = []
for elem in json_data:
vids += elem['vids']
self.im_paths = []
for vid in vids:
im_paths = glob(os.path.join(cfg.FRAME_DIR, vid + "/*.jpg"))
im_paths.sort()
self.im_paths += im_paths
print(cfg.SPLIT, "num_img", len(self.im_paths))
def __init__(self, config: str, checkpoint: str, conf_threshold: float = 0.5, **kwargs):
super(DetectronRCNNPredictor).__init__()
detectron2_cfg = get_cfg()
detectron2_cfg.merge_from_file(config)
if checkpoint is not None:
detectron2_cfg.MODEL.WEIGHTS = checkpoint
self.model = build_model(detectron2_cfg)
self.model.eval()
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(detectron2_cfg.MODEL.WEIGHTS)
self.transform_gen = T.ResizeShortestEdge(
[detectron2_cfg.INPUT.MIN_SIZE_TEST, detectron2_cfg.INPUT.MIN_SIZE_TEST], detectron2_cfg.INPUT.MAX_SIZE_TEST
)
self.conf_threshold = conf_threshold
def build_augmentation(cfg):
"""
Create a list of default :class:`Augmentation` from config.
Now it includes resizing and flipping.
Returns:
list[Augmentation]
"""
min_size = cfg.INPUT.MIN_SIZE_TRAIN
max_size = cfg.INPUT.MAX_SIZE_TRAIN
sample_style = cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING
augmentation = [
T.ResizeShortestEdge(min_size, max_size, sample_style),
T.RandomFlip(prob=0.5, horizontal=True, vertical=False)
]
return augmentation
def build_train_loader(cls, cfg):
# return build_detection_train_loader(cfg, mapper=mapper)
return build_detection_train_loader(
cfg,
mapper=DatasetMapper(
cfg,
is_train=True,
augmentations=[
T.ResizeShortestEdge(short_edge_length=[900, 1200],
max_size=1600,
sample_style='range'),
T.RandomFlip(),
# T.RandomRotation(-30, 30)
# T.RandomCrop('relative_range', (0.5, 0.5)),
# T.RandomContrast(0.8, 1.2),
# T.RandomBrightness(0.8, 1.2),
# T.RandomExtent((0.2, 0.8), (0.2, 0.2))
]))
def __init__(self, cfg_path: str, num_workers: int = 4) -> None:
cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file(cfg_path))
# NOTE: you may customize cfg settings
# cfg.MODEL.DEVICE="cuda" # use gpu by default
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5
# Find a model from detectron2's model zoo. You can use the https://dl.fbaipublicfiles... url as well
# you can also give a path to you checkpoint
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(cfg_path)
self.cfg = cfg.clone()
self.model = build_model(cfg)
self.model.eval()
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.aug = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST],
cfg.INPUT.MAX_SIZE_TEST)
self.pool = Pool(num_workers)
def ResizeShortestEdgeOp(
cfg: CfgNode, arg_str: str, is_train: bool
) -> List[d2T.Transform]:
if is_train:
min_size = cfg.INPUT.MIN_SIZE_TRAIN
max_size = cfg.INPUT.MAX_SIZE_TRAIN
sample_style = cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING
else:
min_size = cfg.INPUT.MIN_SIZE_TEST
max_size = cfg.INPUT.MAX_SIZE_TEST
sample_style = "choice"
if sample_style == "range":
assert (
len(min_size) == 2
), "more than 2 ({}) min_size(s) are provided for ranges".format(len(min_size))
tfm_gens = []
if not min_size == 0: # set to zero to disable resize
tfm_gens.append(d2T.ResizeShortestEdge(min_size, max_size, sample_style))
return tfm_gens
def run_model_single_image(request_bytes, model, cfg):
img, meta = open_image_and_meta(request_bytes)
if img.dtype == "int16": # assuming it's read from araster and needs to be rescaled
img = rescale_tif(img)
rgb_img = img[:, :, ::
-1] # assumes image is in BGR order, puts it in RGB order since model expects RGB
aug = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST],
cfg.INPUT.MAX_SIZE_TEST)
with torch.no_grad():
height, width = img.shape[:2]
print("Type of input data for inference (should be uint8):")
print(rgb_img.dtype)
assert rgb_img.dtype == "uint8"
img = aug.get_transform(rgb_img).apply_image(rgb_img)
img = torch.as_tensor(img.astype("float32").transpose(2, 0, 1))
inputs = {"image": img, "height": height, "width": width}
predictions = model([inputs])
cpu_output = predictions[0]["instances"].to("cpu")
return cpu_output, rgb_img
def __init__(self):
cfg = detcfg.get_cfg()
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0
cfg.MODEL.ROI_HEADS.NMS_THRESH_TEST = 0.5
cfg.merge_from_file(
model_zoo.get_config_file(
"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(
"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml")
self.cfg = cfg
self.predictor = DefaultPredictor(cfg)
self.aug = transforms.ResizeShortestEdge(
[self.cfg.INPUT.MIN_SIZE_TEST, self.cfg.INPUT.MIN_SIZE_TEST],
self.cfg.INPUT.MAX_SIZE_TEST,
)
# sel_classes = ["frisbee", "baseball bat", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "pizza", "hot dog", "pizza", "donut", "cake", "potted plant", "tv", "laptop", "mouse", "remote", "cell phone", "book", "clock", "vase", "scissors"]
sel_classes = ["frisbee"]
self.thing_idxs = [
coco.class_names.index(cls) - 1 for cls in sel_classes
]
def build_augmentation(cfg, is_train):
"""
Create a list of default :class:`Augmentation` from config.
Now it includes resizing and flipping.
Returns:
list[Augmentation]
"""
if is_train:
min_size = cfg.INPUT.MIN_SIZE_TRAIN
max_size = cfg.INPUT.MAX_SIZE_TRAIN
sample_style = cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING
else:
min_size = cfg.INPUT.MIN_SIZE_TEST
max_size = cfg.INPUT.MAX_SIZE_TEST
sample_style = "choice"
augmentation = [T.ResizeShortestEdge(min_size, max_size, sample_style)]
if is_train:
augmentation.append(T.RandomFlip())
return augmentation
def build_polyp_segm_train_aug(cfg):
augs = [
T.ResizeShortestEdge(cfg.INPUT.MIN_SIZE_TRAIN,
cfg.INPUT.MAX_SIZE_TRAIN,
cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING)
]
if cfg.INPUT.CROP.ENABLED:
augs.append(
T.RandomCrop_CategoryAreaConstraint(
cfg.INPUT.CROP.TYPE,
cfg.INPUT.CROP.SIZE,
cfg.INPUT.CROP.SINGLE_CATEGORY_MAX_AREA,
cfg.MODEL.SEM_SEG_HEAD.IGNORE_VALUE,
))
if cfg.INPUT.BLUR.ENABLED:
augs.append(
MotionBlur(prob=cfg.INPUT.BLUR.Prob,
kernel=cfg.INPUT.BLUR.KERNEL_SIZE))
augs.append(T.RandomFlip())
return augs
def __init__(self, cfg, togpu=False, modelPath=None):
self.cfg = cfg.clone() # cfg can be modified by model
# self.cfg.MODEL.WEIGHTS = modelPath
self.model = build_model(self.cfg)
self.model.eval()
checkpointer = DetectionCheckpointer(self.model)
if modelPath == None:
checkpointer.load(self.cfg.MODEL.WEIGHTS)
print("Load weight from : ", self.cfg.MODEL.WEIGHTS)
else:
checkpointer.load(modelPath)
print("Load weight from : ", modelPath)
self.aug = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST],
cfg.INPUT.MAX_SIZE_TEST)
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def from_config(cls, cfg, is_train):
ret = super().from_config(cfg, is_train)
del ret['augmentations']
if cfg.INPUT.RESIZE_META:
augmentations = [
T.Resize((cfg.INPUT.META_MIN_SIZE, cfg.INPUT.META_MIN_SIZE))
]
else:
augmentations = [
T.ResizeShortestEdge(cfg.INPUT.META_MIN_SIZE,
cfg.INPUT.META_MAX_SIZE, "choice")
]
if is_train and cfg.INPUT.RANDOM_FLIP != "none":
augmentations.append(
T.RandomFlip(
horizontal=cfg.INPUT.RANDOM_FLIP == "horizontal",
vertical=cfg.INPUT.RANDOM_FLIP == "vertical",
))
ret['augmentations'] = augmentations
ret['is_train'] = True
return ret
def build_transform_gen(cfg, is_train):
"""
Create a list of :class:`TransformGen` from config.
Now it includes resizing and flipping.
Returns:
list[TransformGen]
"""
if is_train:
min_size = cfg.INPUT.MIN_SIZE_TRAIN
max_size = cfg.INPUT.MAX_SIZE_TRAIN
sample_style = cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING
else:
min_size = cfg.INPUT.MIN_SIZE_TEST
max_size = cfg.INPUT.MAX_SIZE_TEST
sample_style = "choice"
if sample_style == "range":
assert len(
min_size
) == 2, "more than 2 ({}) min_size(s) are provided for ranges".format(
len(min_size))
logger = logging.getLogger(__name__)
tfm_gens = []
tfm_gens.append(T.ResizeShortestEdge(min_size, max_size, sample_style))
if is_train:
if cfg.INPUT.VFLIP:
tfm_gens.append(T.RandomFlip(vertical=True, horizontal=False))
if cfg.INPUT.HFLIP:
tfm_gens.append(T.RandomFlip(vertical=False, horizontal=True))
if cfg.INPUT.RANDOM_CONTRAST.ENABLED:
tfm_gens.append(
T.RandomContrast(cfg.INPUT.RANDOM_CONTRAST.MIN,
cfg.INPUT.RANDOM_CONTRAST.MAX))
if cfg.INPUT.RANDOM_BRIGHTNESS.ENABLED:
tfm_gens.append(
T.RandomBrightness(cfg.INPUT.RANDOM_BRIGHTNESS.MIN,
cfg.INPUT.RANDOM_BRIGHTNESS.MAX))
logger.info("TransformGens used in training: " + str(tfm_gens))
return tfm_gens
def predict(self, original_image: np.ndarray) -> Dict:
_aug = T.ResizeShortestEdge([800, 800], 1333)
height, width = original_image.shape[:2]
image = _aug.get_transform(original_image).apply_image(original_image)
image = torch.as_tensor(image.astype("float32").transpose(2, 0, 1))
inputs = {"image": image, "height": height, "width": width}
predictions = self.artifacts.model([inputs])[0]
pred_instances = predictions["instances"]
boxes = (pred_instances.pred_boxes).to("cpu").tensor.detach().numpy()
scores = (pred_instances.scores).to("cpu").detach().numpy()
pred_classes = (pred_instances.pred_classes).to("cpu").detach().numpy()
pred_masks = (pred_instances.pred_masks).to("cpu").detach().numpy()
result = {
"boxes": boxes,
"scores": scores,
"classes": pred_classes,
"masks": pred_masks,
}
return result
def __init__(self, cfg_file, model_path, classes, confidence_thresh=0.5):
self.cpu_device = torch.device("cpu")
self.cfg = get_cfg()
self.cfg.merge_from_file(cfg_file)
self.cfg.MODEL.WEIGHTS = os.path.join(model_path, "model_final.pth")
self.cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = confidence_thresh
self.model = build_model(self.cfg)
self.model.eval()
MetadataCatalog.get(self.cfg.DATASETS.TEST[0]).thing_classes = classes
self.metadata = MetadataCatalog.get(self.cfg.DATASETS.TEST[0])
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(self.cfg.MODEL.WEIGHTS)
self.transform_gen = T.ResizeShortestEdge(
[self.cfg.INPUT.MIN_SIZE_TEST, self.cfg.INPUT.MIN_SIZE_TEST],
self.cfg.INPUT.MAX_SIZE_TEST)
self.input_format = self.cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(
self,
config="./detectron2/configs/COCO-InstanceSegmentation/small.yaml",
model="detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl"
):
self.cfg = get_cfg()
self.cfg.merge_from_file(config)
self.cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.7 # set threshold for this model
# cfg.MODEL.WEIGHTS = "detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl"
self.model = build_model(self.cfg) # returns a torch.nn.Module
DetectionCheckpointer(self.model).load(
model) # must load weights this way, can't use
self.model.train(False)
self.transform_gen = T.ResizeShortestEdge(
[self.cfg.INPUT.MIN_SIZE_TEST, self.cfg.INPUT.MIN_SIZE_TEST],
self.cfg.INPUT.MAX_SIZE_TEST)
self.input_format = self.cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(self, cf, cf_add_d2, dataset, out):
num_classes = len(dataset.action_names)
TEST_DATASET_NAME = 'daly_objaction_test'
# / Define d2 conf
d2_output_dir = str(small.mkdir(out / 'd2_output'))
d_cfg = set_detectron_cfg_base(d2_output_dir, num_classes, cf['seed'])
d_cfg = set_detectron_cfg_test(d_cfg,
TEST_DATASET_NAME,
cf['d2_rcnn.model'],
cf['d2_rcnn.conf_thresh'],
cf_add_d2,
freeze=False)
d_cfg.MODEL.PROPOSAL_GENERATOR.NAME = "PrecomputedProposals"
d_cfg.freeze()
# / Start d2
simple_d2_setup(d_cfg)
# Predictor without proposal generator
model = build_model(d_cfg)
model.eval()
checkpointer = DetectionCheckpointer(model)
checkpointer.load(d_cfg.MODEL.WEIGHTS)
MIN_SIZE_TEST = d_cfg.INPUT.MIN_SIZE_TEST
MAX_SIZE_TEST = d_cfg.INPUT.MAX_SIZE_TEST
transform_gen = d2_transforms.ResizeShortestEdge(
[MIN_SIZE_TEST, MIN_SIZE_TEST], MAX_SIZE_TEST)
# Instance monkeypatching
# https://stackoverflow.com/questions/50599045/python-replacing-a-function-within-a-class-of-a-module/50600307#50600307
model.forward = MethodType(genrcnn_rcnn_roiscores_forward, model)
self.d_cfg = d_cfg
self.rcnn_roiscores_model = model
self.cpu_device = torch.device("cpu")
self.transform_gen = transform_gen
def __init__(self, cfg, is_train=True):
if cfg.INPUT.CROP.ENABLED and is_train:
self.crop_gen = [
T.ResizeShortestEdge([400, 500, 600], sample_style="choice"),
T.RandomCrop(cfg.INPUT.CROP.TYPE, cfg.INPUT.CROP.SIZE),
]
else:
self.crop_gen = None
self.mask_on = cfg.MODEL.MASK_ON
self.unlabeled_region_on = cfg.MODEL.EOPSN.UNLABELED_REGION
# Semantic Segmentation
self.ignore_value = cfg.MODEL.SEM_SEG_HEAD.IGNORE_VALUE
self.sem_seg_unlabeled_region_on = cfg.MODEL.EOPSN.SEM_SEG_UNLABELED_REGION
self.num_sem_seg_classes = cfg.MODEL.SEM_SEG_HEAD.NUM_CLASSES
self.tfm_gens = build_transform_gen(cfg, is_train)
logging.getLogger(__name__).info(
"Full TransformGens used in training: {}, crop: {}".format(
str(self.tfm_gens), str(self.crop_gen)))
self.img_format = cfg.INPUT.FORMAT
self.is_train = is_train
unseen_path = cfg.DATASETS.UNSEEN_LABEL_SET
if unseen_path != '' and self.is_train:
meta = MetadataCatalog.get(cfg.DATASETS.TRAIN[0]).thing_classes
self.unseen_label_set = self._get_unseen_label_set(
meta, unseen_path)
else:
self.unseen_label_set = None
if cfg.MODEL.LOAD_PROPOSALS:
self.proposal_topk = (cfg.DATASETS.PRECOMPUTED_PROPOSAL_TOPK_TRAIN
if is_train else
cfg.DATASETS.PRECOMPUTED_PROPOSAL_TOPK_TEST)
else:
self.proposal_topk = None
def get_sample_inputs(args):
if args.sample_image is None:
# get a first batch from dataset
data_loader = build_detection_test_loader(cfg, cfg.DATASETS.TEST[0])
first_batch = next(iter(data_loader))
return first_batch
else:
# get a sample data
original_image = detection_utils.read_image(args.sample_image, format=cfg.INPUT.FORMAT)
# Do same preprocessing as DefaultPredictor
aug = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST
)
height, width = original_image.shape[:2]
image = aug.get_transform(original_image).apply_image(original_image)
image = torch.as_tensor(image.astype("float32").transpose(2, 0, 1))
inputs = {"image": image, "height": height, "width": width}
# Sample ready
sample_inputs = [inputs]
return sample_inputs
def __init__(
self,
resize_type="resize_shortest",
resize_short=None,
resize_max=None,
box_scale_factor=1.0,
):
super().__init__()
assert resize_type in ["resize_shortest", "resize", "None", None]
resizer = None
if resize_type == "resize_shortest":
resizer = transforms.ResizeShortestEdge(resize_short, resize_max)
elif resize_type == "resize":
resizer = transforms.Resize(resize_short)
self.aug = [
tfm_tensor.Tensor2Array(),
tfm_crop.CropBoxAug(box_scale_factor=box_scale_factor),
*([resizer] if resizer else []),
tfm_tensor.Array2Tensor(),
]
def build_aug_transforms(
cfg: detectron2.config.CfgNode,
flip_horiz: bool = True,
flip_vert: bool = False,
max_rotate: int = 10,
brightness_limits: Tuple[int, int] = (0.8, 1.4),
contrast_limits: Tuple[int, int] = (0.8, 1.4),
saturation_limits: Tuple[int, int] = (0.8, 1.4),
p_lighting: float = 0.75
) -> detectron2.data.transforms.AugmentationList:
"Build a list of detectron2 augmentations"
augs = []
augs.append(
T.ResizeShortestEdge(cfg.INPUT.MIN_SIZE_TRAIN,
cfg.INPUT.MAX_SIZE_TRAIN,
cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING))
if flip_horiz:
augs.append(T.RandomFlip(prob=0.5, horizontal=True, vertical=False))
if flip_vert:
augs.append(T.RandomFlip(prob=0.5, horizontal=False, vertical=True))
if max_rotate:
augs.append(
T.RandomRotation(angle=[-max_rotate, max_rotate], expand=False))
if brightness_limits:
augs.append(
T.RandomApply(prob=p_lighting,
tfm_or_aug=T.RandomBrightness(*brightness_limits)))
if contrast_limits:
augs.append(
T.RandomApply(prob=p_lighting,
tfm_or_aug=T.RandomContrast(*contrast_limits)))
if saturation_limits:
augs.append(
T.RandomApply(prob=p_lighting,
tfm_or_aug=T.RandomSaturation(*saturation_limits)))
return augs
def build_gdrn_augmentation(cfg, is_train):
"""Create a list of :class:`Augmentation` from config. when training 6d
pose, cannot flip.
Returns:
list[Augmentation]
"""
if is_train:
min_size = cfg.INPUT.MIN_SIZE_TRAIN
max_size = cfg.INPUT.MAX_SIZE_TRAIN
sample_style = cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING
else:
min_size = cfg.INPUT.MIN_SIZE_TEST
max_size = cfg.INPUT.MAX_SIZE_TEST
sample_style = "choice"
if sample_style == "range":
assert len(min_size) == 2, "more than 2 ({}) min_size(s) are provided for ranges".format(len(min_size))
augmentation = []
augmentation.append(T.ResizeShortestEdge(min_size, max_size, sample_style))
if is_train:
# augmentation.append(T.RandomFlip())
logger.info("Augmentations used in training: " + str(augmentation))
return augmentation
def build_augmentation(cfg, is_train):
"""
With option to don't use hflip
Returns:
list[Augmentation]
"""
if is_train:
min_size = cfg.INPUT.MIN_SIZE_TRAIN
max_size = cfg.INPUT.MAX_SIZE_TRAIN
sample_style = cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING
else:
min_size = cfg.INPUT.MIN_SIZE_TEST
max_size = cfg.INPUT.MAX_SIZE_TEST
sample_style = "choice"
if sample_style == "range":
assert (
len(min_size) == 2
), "more than 2 ({}) min_size(s) are provided for ranges".format(
len(min_size))
logger = logging.getLogger(__name__)
augmentation = []
augmentation.append(T.ResizeShortestEdge(min_size, max_size, sample_style))
if is_train:
if cfg.INPUT.HFLIP_TRAIN:
augmentation.append(T.RandomFlip())
if cfg.INPUT.BRIGHTNESS_TRAIN:
augmentation.append(T.RandomBrightness(0.9, 1.1))
if cfg.INPUT.CONTRAST_TRAIN:
augmentation.append(T.RandomContrast(0.9, 1.1))
if cfg.INPUT.SATURATION_TRAIN:
augmentation.append(T.RandomSaturation(0.9, 1.1))
logger.info("Augmentations used in training: " + str(augmentation))
return augmentation
def load(self, path):
try:
from detectron2.checkpoint import (
DetectionCheckpointer, ) # noqa # pylint: disable=unused-import
from detectron2.modeling import META_ARCH_REGISTRY
from detectron2.config import get_cfg
from detectron2.data import transforms as T
except ImportError:
raise MissingDependencyException(
"Detectron package is required to use DetectronArtifact")
cfg = get_cfg()
cfg.merge_from_file(f"{path}/{self._file_name}.yaml")
meta_arch = META_ARCH_REGISTRY.get(cfg.MODEL.META_ARCHITECTURE)
self._model = meta_arch(cfg)
self._model.eval()
device = self._metadata['device']
self._model.to(device)
checkpointer = DetectionCheckpointer(self._model)
checkpointer.load(f"{path}/{self._file_name}.pth")
self._aug = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST],
cfg.INPUT.MAX_SIZE_TEST)
return self.pack(self._model)
def __init__(self, cfg, hooks=[]):
self.cfg = cfg.clone() # cfg can be modified by model
self.model = build_model(self.cfg)
self.model.eval()
if len(hooks) == 2:
for m in self.model.modules():
if isinstance(m, ACM):
m.add_mod.register_forward_hook(hooks[0])
m.sub_mod.register_forward_hook(hooks[1])
m.add_mod.return_weight = True
m.sub_mod.return_weight = True
print("adding a hook")
self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0])
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.transform_gen = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST],
cfg.INPUT.MAX_SIZE_TEST)
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def build_transform_gen(cfg, is_train):
"""
Create a list of :class:`TransformGen` from config.
Now it includes resizing and flipping.
Returns:
list[TransformGen]
"""
if is_train:
min_size = cfg.INPUT.MIN_SIZE_TRAIN
max_size = cfg.INPUT.MAX_SIZE_TRAIN
sample_style = cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING
else:
min_size = cfg.INPUT.MIN_SIZE_TEST
max_size = cfg.INPUT.MAX_SIZE_TEST
sample_style = "choice"
if sample_style == "range":
assert len(
min_size
) == 2, "more than 2 ({}) min_size(s) are provided for ranges".format(
len(min_size))
logger = logging.getLogger(__name__)
tfm_gens = []
tfm_gens.append(T.ResizeShortestEdge(min_size, max_size, sample_style))
if is_train:
tfm_gens.append(T.RandomFlip())
tfm_gens.extend([
T.RandomBrightness(0.5, 1.5),
T.RandomContrast(0.5, 1.5),
T.RandomSaturation(0.5, 1.2),
T.RandomLighting(1.0),
])
logger.info("TransformGens used in training: " + str(tfm_gens))
print("TransformGens used in training: " + str(tfm_gens))
return tfm_gens
