def __init__(self):
self.gen = 1000
self.cfg = get_cfg_defaults()
self.cfg.model.mode = "test_inference"
self.dataset = Dataset(None, self.cfg)
self.auto_anchors = AutoAnchors(self.dataset, self.cfg.model, self.gen)
self.k_points = torch.ones((12, 2)) * 2.0
self.wh = torch.ones((1000, 2)) * 2.0
def test_preprocessing(self):
config = get_cfg_defaults()
config.model.strides = [8, 16, 32]
config.model.n_classes = 80
config.model.image_size = 640
config.model.input_channels = 3
config.freeze()
model = PreprocessTargets(config.model)
model = inferenceModel(model.half())
x = torch.zeros((1, 90, 5))
real_labels = torch.tensor([[45.0000, 0.4795, 0.6416, 0.9556, 0.4466], [45.0000, 0.7365, 0.3104, 0.4989, 0.3573]])
x[:, :real_labels.shape[0]] = real_labels
t_indices_boxes_p5, t_indices_boxes_p4, t_indices_boxes_p3 = model(x)
anchor_ind_p5, yind_p5, xind_p5, t_boxes_p5 = t_indices_boxes_p5
anchor_ind_p4, yind_p4, xind_p4, t_boxes_p4 = t_indices_boxes_p4
anchor_ind_p3, yind_p3, xind_p3, t_boxes_p3 = t_indices_boxes_p3
n_digits = 3
t_boxes_p4 = torch.round(t_boxes_p4 * 10**n_digits) / (10**n_digits)
t_boxes_p3 = torch.round(t_boxes_p3 * 10**n_digits) / (10**n_digits)
size = 5 * len(config.model.anchors.p3width) * config.dataset.max_bbox_per_scale
assert anchor_ind_p5.shape == torch.Size([size])
assert yind_p4.shape == torch.Size([size])
assert xind_p3.shape == torch.Size([size])
assert t_boxes_p5.shape == torch.Size([size, 5])
assert xind_p5[xind_p5 != 0.].numel() == 0
_, index_t_boxes_p4 = torch.sort(t_boxes_p4.sum(axis=-1))
_, index_t_boxes_p3 = torch.sort(t_boxes_p3.sum(axis=-1))
t_boxes_p4 = t_boxes_p4[index_t_boxes_p4]
t_boxes_p3 = t_boxes_p3[index_t_boxes_p3]
assert torch.all(torch.eq(anchor_ind_p4[anchor_ind_p4 != 0.].sum(), torch.tensor([3, 3, 3, 1, 3, 2, 2, 3, 2, 1, 3, 1]).sum()))
assert torch.all(torch.eq(yind_p3[yind_p3 != 0.].sum(), torch.tensor([13, 13, 13, 13, 12, 12, 12, 12, 12, 12, 12, 12, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5]).sum()))
assert t_boxes_p5[t_boxes_p5 != 0.].numel() == 0
assert torch.all(torch.eq(t_boxes_p4[t_boxes_p4 != 0.].view(-1, 5)[-2:], torch.tensor([[45.0000, 0.1800, 0.6640, 38.2240, 17.8640],
[45.0000, 1.1800, 0.6640, 38.2240, 17.8640]])))
assert torch.all(torch.eq(t_boxes_p3[t_boxes_p3 != 0.].view(-1, 5)[-2:], torch.tensor([[45.0000, 0.5900, 0.8320, 19.1120, 8.9320],
[45.0000, 0.5900, 0.8320, 19.1120, 8.9320]])))
def get_cfg():
cfg = get_cfg_defaults()
cfg.model.image_size = 416
cfg.inference.nms = True
cfg.inference.class_conf_threshold = 0.001
cfg.inference.iou_threshold = 0.65
cfg.inference.nms_max_detections = 10
cfg.inference.pre_nms_topk_k = 1180
cfg.ipuopts.batches_per_step = 1
cfg.model.normalization = "batch"
cfg.model.activation = "mish"
cfg.model.half = False
cfg.model.uint_io = True
cfg.model.input_channels = 3
cfg.model.micro_batch_size = 1
cfg.model.mode = "test"
cfg.model.ipu = True
return cfg
def test_nms(self):
cfg_inference = get_cfg_defaults().inference
cfg_inference.class_conf_threshold = 0.1
cfg_inference.iou_threshold = 0.1
cfg_inference.nms_max_detections = 6
batch_size = 2
n_elements = 6
n_classes = 2
ipu_model = Nms(cfg_inference, cpu_mode=False)
cpu_model = Nms(cfg_inference, cpu_mode=True)
ipu_model = poptorch.inferenceModel(ipu_model)
scores = torch.tensor([.9, .1, .25, .75, .4, .6, .95, .05, .5, .5, .3, .7,
.9, .1, .25, .75, .4, .6, .95, .05, .5, .5, .3, .7], dtype=torch.float32).reshape(batch_size, n_elements, n_classes)
boxes = torch.tensor([0, 0, 1, 1, 0, 0.1, 1, 1.1, 0, -0.1, 1, 0.9, 0, 10, 1, 11, 0, 10.1, 1, 11.1,
0, 100, 1, 101, 0, 0, 1, 1, 0, 0.1, 1, 1.1, 0, -0.1, 1, 0.9, 0, 10, 1, 11,
0, 10.1, 1, 11.1, 0, 100, 1, 101], dtype=torch.float32).reshape(batch_size, n_elements, 4)
res_ipu = ipu_model(scores, boxes)
classes = torch.tensor([[0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]], dtype=torch.int32)
sorted_idx, _ = torch.arange(0, boxes.shape[1], 1).repeat(n_classes).sort()
boxes = boxes.index_select(1, sorted_idx)
shifting = 4.
box_shift = (classes.float() * shifting).unsqueeze(axis=-1).float()
shifted_box = boxes.view(batch_size, n_elements * n_classes, 4) + box_shift
res_cpu = cpu_model(scores.view(2, -1), shifted_box, classes)
box_shift = (res_cpu[3].float() * shifting).unsqueeze(axis=-1).float()
assert torch.equal(res_ipu[0].long(), res_cpu[0] // n_classes)
assert torch.equal(res_ipu[1], res_cpu[1])
assert torch.all(res_ipu[2] - (res_cpu[2] - box_shift) < 2e-07)
assert torch.equal(res_ipu[3], res_cpu[3])
assert torch.equal(res_ipu[4], res_cpu[4])
def load_config(parser_config):
"""
load default config and merge user config
Returns:
"""
# parser = set_argparse()
# load config file
cfg = get_cfg_defaults()
config_file = Path(__file__).parent.parent.joinpath("config.yaml")
assert isinstance(
parser_config, str), "input must single file->id or single folder"
if parser_config:
merge_config(cfg, parser_config)
elif config_file.exists():
merge_config(cfg, str(config_file))
else:
logger.info("use defalt config")
return cfg
# def cid(self):
# string = self.html.xpath("//a[contains(@class,'sample-box')][1]/@href")[
# 0].replace('https://pics.dmm.co.jp/digital/video/', '')
# self.data.cid = re.sub('/.*?.jpg', '', string)
class JavbusBuilder:
def __init__(self):
self._instance = None
def __call__(self, number, cfg):
if not self._instance:
self._instance = Javbus(number, cfg)
for method in dir(self._instance):
fun = getattr(self._instance, method)
if getattr(fun, "is_callable", False):
fun()
return self._instance.data
if __name__ == "__main__":
pass
# for test
# pass
from utils.config import get_cfg_defaults
#
cfgs = get_cfg_defaults()
jav = Javbus("111720_001", cfgs)
print(jav.data)
return max_nlabels
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument('--data',
type=str,
default='/localdata/datasets/',
help='Dataset')
parser.add_argument('--config',
type=str,
default='configs/inference-yolov4p5.yaml',
help='Configuration of the model')
opt = parser.parse_args()
cfg = get_cfg_defaults()
cfg.merge_from_file(opt.config)
cfg.model.auto_anchors = True
image_sizes = [896]
for image_size in image_sizes:
anchors = find_optimal_anchors(opt,
cfg,
gen=1000,
image_size=image_size)
print("Optimal anchors are: ")
print("p3 width: ", anchors[0].widths)
print("p3 height: ", anchors[0].heights)
print("p4 width: ", anchors[1].widths)
print("p4 height: ", anchors[1].heights)
class TestYolov4P5:
"""Tests for end-to-end training and infernece of Yolov4P5."""
cfg = get_cfg_defaults()
cfg.model.image_size = 64
input_tensor = torch.Tensor(np.random.rand(1, 3, 64, 64))
@pytest.mark.ipus(1)
@pytest.mark.skip(reason="to enable when loss is implemented")
def test_training(self):
model = Yolov4P5(self.cfg)
optimizer = torch.optim.SGD(model.parameters(),
lr=0.01,
momentum=0.9,
nesterov=False)
model = trainingModel(model.half(), optimizer=optimizer)
loss = model(self.input_tensor)
# TODO implement test when loss is implemented.
@pytest.mark.ipus(1)
def test_inference(self):
self.cfg.inference.nms = False
model = Yolov4P5(self.cfg)
model = inferenceModel(model.half().eval())
y = model(self.input_tensor)
expected_output_size = model.output_shape((64, 64))
p3 = expected_output_size['p3']
p4 = expected_output_size['p4']
p5 = expected_output_size['p5']
assert y[0].shape == torch.Size([p3[0], p3[1] * p3[2] * p3[3], p3[4]])
assert y[1].shape == torch.Size([p4[0], p4[1] * p4[2] * p4[3], p4[4]])
assert y[2].shape == torch.Size([p5[0], p5[1] * p5[2] * p5[3], p5[4]])
@pytest.mark.ipus(1)
def test_nms(self):
cfg = get_cfg()
transformed_images, transformed_labels, image_sizes = get_image_and_label(
cfg)
model = prepare_model(cfg)
y = model(transformed_images)
seen, nt, mean_precision, mean_recall, m_ap50, m_ap = post_process_and_eval(
cfg, y, image_sizes, transformed_labels)
assert seen == 1
assert nt == 10
assert mean_precision == 0.4304926702679917
assert mean_recall == 0.75
assert m_ap50 == 0.6837500000000001
assert m_ap == 0.5860250329380764
@pytest.mark.ipus(1)
def test_inference_cpu_and_ipu(self):
self.cfg.model.half = False
self.cfg.model.image_size = 416
self.cfg.inference.nms = False
# Create CPU model
torch.manual_seed(0)
self.cfg.model.ipu = False
model = Yolov4P5(self.cfg)
cpu_model = model.eval()
y_cpu = cpu_model(self.input_tensor)
# Create IPU model
torch.manual_seed(0)
self.cfg.model.ipu = True
model = Yolov4P5(self.cfg)
ipu_model = inferenceModel(model.eval())
y_ipu = ipu_model(self.input_tensor)
assert torch.max(torch.abs(y_cpu[0] - y_ipu[0])) <= 0.002
assert torch.max(torch.abs(y_cpu[1] - y_ipu[1])) <= 0.002
assert torch.max(torch.abs(y_cpu[2] - y_ipu[2])) <= 0.002
def test_fused_inference(self):
self.cfg.model.normalization = 'batch'
self.cfg.model.half = False
self.cfg.inference.nms = False
model = Yolov4P5(self.cfg)
before_fuse_model = inferenceModel(model.eval())
before_fuse_output = before_fuse_model(self.input_tensor)
model.optimize_for_inference()
after_fuse_model = inferenceModel(model.eval())
after_fuse_output = after_fuse_model(self.input_tensor)
assert torch.max(
torch.abs(after_fuse_output[0] - before_fuse_output[0])) <= 1e-4
assert torch.max(
torch.abs(after_fuse_output[1] - before_fuse_output[1])) <= 1e-4
assert torch.max(
torch.abs(after_fuse_output[2] - before_fuse_output[2])) <= 1e-4
