def __init__(self, hyper_params):
self.batch_size = hyper_params.batch
self.n_cls = hyper_params.n_cls
self.classes = hyper_params.classes
root = hyper_params.root
self.cuda = True if torch.cuda.is_available() else False
self.model_name = hyper_params.model_name
model_cfg = hyper_params.model_cfg
model_type = model_cfg.pop('type')
assert model_type in models.__dict__
self.bg = model_cfg.pop('background')
model_cfg['weights'] = hyper_params.weights
model_cfg['head'][
'num_classes'] = self.n_cls + 1 if self.bg else self.n_cls
self.net = models.__dict__[model_type](**model_cfg)
setattr(self.net, 'num_classes', model_cfg['head']['num_classes'])
if self.cuda:
self.net.cuda()
self.net.eval()
self.input_size = hyper_params.input_size
setattr(self.net, 'input_size', self.input_size)
transform = [dt.Resize_Pad(self.input_size), dt.ToTensor()]
if hyper_params.norm:
transform += [
dt.Normalize(hyper_params.norm['mean'],
hyper_params.norm['std'])
]
ann_file = root + hyper_params.ann_file
img_dir = root + hyper_params.img_dir
if hasattr(hyper_params, 'json'):
self.dataset = dt.JsonDataset(
ann_file,
img_dir,
transform=transforms.Compose(transform),
city=hyper_params.city)
else:
self.dataset = dt.VOCDataset(
ann_file, img_dir, transform=transforms.Compose(transform))
setattr(self.dataset, 'with_bg', self.bg)
self.dataloader = DataLoader(
self.dataset,
batch_size=self.batch_size,
shuffle=False,
# num_workers=hyper_params.nworkers if self.cuda else 0,
# pin_memory=hyper_params.pin_mem if self.cuda else False,
collate_fn=dt.list_collate,
)
self.conf_thresh = hyper_params.conf_th
self.nms_thresh = hyper_params.nms_th
self.ignore_thresh = hyper_params.ignore_th
self.n_det = hyper_params.n_det
def main():
parser = argparse.ArgumentParser('Visualize patch distances')
parser.add_argument('-i', '--img', type=str, default='0',
help='Image. If an integer, uses it as an index into a list of image'
'files. If a filename, uses the image in that file. If the string '
'"rand", chooses a random image from the list of image files.')
parser.add_argument('-p', '--point', type=int, nargs=2, default=(-1, -1),
help='(x, y) point to use as top right corner of reference patch. If '
'(-1, -1), then choose a random point.')
parser.add_argument('-k', '--patch-size', type=int, default=15,
help='Size of a patch (square).')
parser.add_argument('-s', '--size', type=int, default=320,
help='Size of the longer side of the image after resize')
parser.add_argument('-w', '--whiten', action='store_true',
help='Whiten each patch individually before calculating distances.')
parser.add_argument('--run', type=Path, default='',
help='Path to run directory to use for saved model.')
args = parser.parse_args()
whiten = args.whiten
img_file = get_image_file(args.img)
img = get_image(img_file, args.size)
k = args.patch_size
point = get_point(args.point, k, *img.shape)
print('Calculate patch distance')
reg_dist = patch_distance(img, point, k, whiten)
if not args.run:
run = sorted(list(Path('runs').iterdir()))[-1]
args.run = run
cfg = json.load(open(str(args.run / 'config.json')))
normalizer = dataset.Normalize(cfg['dataset']['kwargs']['normalize'])
net = get_model(model.PyrNet, str(args.run / 'model_weights'))
print('Calculate transformed distance')
dist = calculate_distance(img, point, net, k, normalizer)
print('Show closest patches')
fig, ax = plt.subplots(1, 2, figsize=(24, 12))
show_closest(img, reg_dist, k, ax=ax[0])
show_closest(img, dist, k, ax=ax[1])
ax[0].set_title('Pixel space distance')
ax[1].set_title('Transform space distance')
plt.tight_layout()
plt.show()
def __init__(self, hyper_params):
# get config
self.batch_size = hyper_params.batch
self.mini_batch_size = hyper_params.mini_batch
# subdivision using accumulated grad
self.subdivision = self.batch_size // self.mini_batch_size
self.n_cls = hyper_params.n_cls
self.classes = hyper_params.classes
self.root = hyper_params.root
self.cuda = True if torch.cuda.is_available() else False
self.backup_dir = hyper_params.backup_dir
self.backup = hyper_params.backup
# listening SIGINT while Ctrl + c
self.sigint = False
signal.signal(signal.SIGINT, self.__sigint_handler)
self.model_name = hyper_params.model_name
model_cfg = hyper_params.model_cfg
model_type = model_cfg.pop('type')
assert model_type in models.__dict__
self.bg = model_cfg.pop('background')
model_cfg['weights'] = hyper_params.weights
model_cfg['head'][
'num_classes'] = self.n_cls + 1 if self.bg else self.n_cls
self.net = models.__dict__[model_type](**model_cfg)
if self.cuda:
self.net.cuda()
self.net.train()
self.input_size = hyper_params.input_size
setattr(self.net, 'input_size', self.input_size)
transform = []
if hasattr(hyper_params, 'crop'):
# transform.append(dt.RCM(self.input_size,hyper_params.crop))
transform.append(dt.RC(self.input_size, hyper_params.crop))
# transform.append(dt.RandomCrop(hyper_params.crop))
# transform.append(dt.SSDCrop())
if hasattr(hyper_params, 'flip'):
transform.append(dt.HFlip(hyper_params.flip))
if hasattr(hyper_params, 'hue'):
transform.append(
dt.ColorJitter(hyper_params.exposure, hyper_params.saturation,
hyper_params.hue))
transform += [dt.Resize_Pad(self.input_size), dt.ToTensor()]
if hyper_params.norm:
transform += [
dt.Normalize(hyper_params.norm['mean'],
hyper_params.norm['std'])
]
ann_file = self.root + hyper_params.ann_file
img_dir = self.root + hyper_params.img_dir
if hasattr(hyper_params, 'json'):
dataset = dt.JsonDataset(ann_file,
img_dir,
transform=transforms.Compose(transform),
city=hyper_params.city)
else:
dataset = dt.VOCDataset(ann_file,
img_dir,
transform=transforms.Compose(transform))
setattr(dataset, 'with_bg', self.bg)
self.dataloader = DataLoader(
dataset,
batch_size=self.mini_batch_size,
shuffle=True,
drop_last=True,
num_workers=hyper_params.nworkers if self.cuda else 0,
# pin_memory=hyper_params.pin_mem if self.cuda else False,
collate_fn=dt.list_collate,
)
if hasattr(hyper_params, 'val'):
ann_file = self.root + hyper_params.val['ann_file']
img_dir = self.root + hyper_params.val['img_dir']
transform = [dt.Resize_Pad(self.input_size), dt.ToTensor()]
if hyper_params.norm:
transform += [
dt.Normalize(hyper_params.norm['mean'],
hyper_params.norm['std'])
]
if hasattr(hyper_params, 'json'):
valdata = dt.JsonDataset(
ann_file,
img_dir,
transform=transforms.Compose(transform),
city=hyper_params.city)
else:
valdata = dt.VOCDataset(
ann_file, img_dir, transform=transforms.Compose(transform))
setattr(valdata, 'with_bg', self.bg)
self.valloader = DataLoader(
valdata,
batch_size=self.mini_batch_size,
num_workers=hyper_params.nworkers if self.cuda else 0,
# pin_memory=hyper_params.pin_mem if self.cuda else False,
collate_fn=dt.list_collate,
)
self.batch_e = len(self.dataloader) // self.subdivision
self.max_batches = hyper_params.max_batches
self.epoches = self.max_batches // self.batch_e
self.optim_cfg = hyper_params.optim_cfg
self.optim = self.make_optimizer(self.net)
self.lr_cfg = hyper_params.lr_cfg
self.scheduler = self.make_lr_scheduler(self.optim)
if hyper_params.ckpt is not None:
state = torch.load(hyper_params.ckpt)
self.net.seen = state['seen']
self.net.load_state_dict(state['net'])
self.optim.load_state_dict(state['optim'])
self.scheduler.load_state_dict(state['sche'])
self.log = {}
def main():
parser = argparse.ArgumentParser('Visualize patch distances')
parser.add_argument(
'-i',
'--img',
type=str,
default='0',
nargs='+',
help='Images. If an integer, uses it as an index into a list of image'
'files. If a filename, uses the image in that file. If the string '
'"rand", chooses a random image from the list of image files.')
parser.add_argument(
'-p',
'--point',
type=int,
nargs=2,
default=(-1, -1),
help='(x, y) point to use as top right corner of reference patch. If '
'(-1, -1), then choose a random point.')
parser.add_argument('-k',
'--patch-size',
type=int,
default=15,
help='Size of a patch (square).')
parser.add_argument(
'-s',
'--size',
type=int,
default=320,
help='Size of the longer side of the image after resize')
parser.add_argument(
'-w',
'--whiten',
action='store_true',
help='Whiten each patch individually before calculating distances.')
parser.add_argument('--run',
type=Path,
default='',
help='Path to run directory to use for saved model.')
args = parser.parse_args()
dset = dataset.TigerData(mode='classification').train()
whiten = args.whiten
imgs = []
# Get all the files
for i in args.img:
img_file = get_image_file(i, dset)
img = pd.get_image(img_file, args.size)
imgs.append(img)
k = args.patch_size
img = imgs[0]
point = pd.get_point(args.point, k, *img.shape)
if not args.run:
run = sorted(list(Path('runs').iterdir()))[-1]
args.run = run
cfg = json.load(open(str(args.run / 'config.json')))
normalizer = dataset.Normalize(cfg['dataset']['kwargs']['normalize'])
net = td.get_model(model.PyrNet, str(args.run / 'model_weights'))
print('Calculate patch distance')
dist = pd.calculate_distance(img, point, k, whiten)
patch_dists = [dist]
patch = extract_patch(img, point, k)
for i in imgs[1:]:
dist = calculate_distance(i,
patch,
net,
k,
transform=False,
normalize=normalizer)
patch_dists.append(dist)
print('Calculate transformed distance')
dist = td.calculate_distance(img, point, net, k, whiten)
trans_dists = [dist]
patch = extract_patch(img, point, k, net)
for i in imgs[1:]:
dist = calculate_distance(i,
patch,
net,
k,
transform=True,
normalize=normalizer)
trans_dists.append(dist)
print('Show closest patches')
fig, ax = plt.subplots(2, len(imgs), figsize=(24, 12))
for i in range(len(imgs)):
show_closest(imgs[i], patch_dists[i], k, ax=ax[0, i])
show_closest(imgs[i], trans_dists[i], k, ax=ax[1, i])
ax[0, i].set_title('Pixel space distance')
ax[1, i].set_title('Transform space distance')
plt.tight_layout()
plt.show()
picked = pd.concat([picked, df_full[df_full['patientid'] == idx]], ignore_index=True)
return picked
if __name__ == '__main__':
images_dir = './data/images'
checkpoints_dir = './checkpoints'
if not os.path.exists(checkpoints_dir):
os.makedirs(checkpoints_dir)
data_transforms = {
'train': torchvision.transforms.Compose([
dataset.RandomRotate(15),
dataset.RandomCrop(512),
dataset.RandomColorShift(),
dataset.Normalize(config.mean, config.std),
dataset.ToTensor(dtype=config.dtype)
]),
'eval': torchvision.transforms.Compose([
dataset.CenterCrop(512),
dataset.Normalize(config.mean, config.std),
dataset.ToTensor(dtype=config.dtype),
]),
}
df = pd.read_csv('./data/all.csv', usecols=['patientid', 'finding', 'filename'])
covid_df = df[df.apply(lambda x: 'COVID-19' in str(x), axis=1)]
other_df = df[df.apply(lambda x: 'COVID-19' not in str(x), axis=1)]
print('Unique COVID-19 images:', len(covid_df))
print('Unique COVID-19 patients:', len(covid_df['patientid'].unique()))
print('Unique other images:', len(other_df))