def __init__(self):
self.model = torchreid.models.build_model(
name='resnet50',
num_classes=1,#unusable
loss='softmax',
pretrained=True,
use_gpu = True
)
torchreid.utils.load_pretrained_weights(self.model, 'model_data/model.pth.tar-60')
self.model = self.model.cuda()
self.optimizer = torchreid.optim.build_optimizer(
self.model,
optim='adam',
lr=0.0003
)
self.scheduler = torchreid.optim.build_lr_scheduler(
self.optimizer,
lr_scheduler='single_step',
stepsize=20
)
_, self.transform_te = build_transforms(
height=256, width=128,
random_erase=False,
color_jitter=False,
color_aug=False
)
self.dist_metric = 'euclidean'
self.model.eval()
def __init__(self,
sources=None,
targets=None,
height=256,
width=128,
transforms='random_flip',
norm_mean=None,
norm_std=None,
use_gpu=False):
self.sources = sources
self.targets = targets
self.height = height
self.width = width
if self.sources is None:
raise ValueError('sources must not be None')
if isinstance(self.sources, str):
self.sources = [self.sources]
if self.targets is None:
self.targets = self.sources
if isinstance(self.targets, str):
self.targets = [self.targets]
self.transform_tr, self.transform_te = build_transforms(
self.height,
self.width,
transforms=transforms,
norm_mean=norm_mean,
norm_std=norm_std)
self.use_gpu = (torch.cuda.is_available() and use_gpu)
def __init__(self, sources=None, targets=None, height=256, width=128, random_erase=False,
color_jitter=False, color_aug=False, use_cpu=False):
self.sources = sources
self.targets = targets
if self.sources is None:
raise ValueError('sources must not be None')
if isinstance(self.sources, str):
self.sources = [self.sources]
if self.targets is None:
self.targets = self.sources
if isinstance(self.targets, str):
self.targets = [self.targets]
self.transform_tr, self.transform_te = build_transforms(
height, width,
random_erase=random_erase,
color_jitter=color_jitter,
color_aug=color_aug
)
self.use_gpu = (torch.cuda.is_available() and not use_cpu)
def __init__(self,
sources=None,
targets=None,
height=256,
width=128,
transforms='random_flip',
use_cpu=False,
load_pose=False):
self.sources = sources
self.targets = targets
if self.sources is None:
raise ValueError('sources must not be None')
if isinstance(self.sources, str):
self.sources = [self.sources]
if self.targets is None:
self.targets = self.sources
if isinstance(self.targets, str):
self.targets = [self.targets]
if load_pose:
self.transform_tr, self.transform_te = build_unified_transforms(
height, width, transforms)
else:
self.transform_tr, self.transform_te = build_transforms(
height, width, transforms)
self.use_gpu = (torch.cuda.is_available() and not use_cpu)
def __init__(
self,
root='',
mode='train',
test_in_train_format=False,
meta_file='',
step=30,
h_len=3,
height=256,
width=128,
loc_std=1,
**kwargs
):
self.root = osp.abspath(osp.expanduser(root))
self.dataset_dir = osp.join(self.root, self.dataset_dir)
self.train_im_dir = osp.join(self.dataset_dir, 'imgs/train')
self.val_im_dir = osp.join(self.dataset_dir, 'imgs/train')
self.test_im_dir = osp.join(self.dataset_dir, 'imgs/test')
self.train_dt_dir = osp.join(self.dataset_dir, 'dts/train')
self.val_dt_dir = osp.join(self.dataset_dir, 'dts/train')
self.test_dt_dir = osp.join(self.dataset_dir, 'dts/test')
self.train_gt_dir = osp.join(self.dataset_dir, 'gts/train')
self.val_gt_dir = osp.join(self.dataset_dir, 'gts/train')
# required_files = [
# self.dataset_dir, self.train_dir, self.query_dir, self.gallery_dir
# ]
# self.check_before_run(required_files)
self.test_mode = mode
self.meta_file = meta_file
self.test_in_train_format = test_in_train_format
self.step = step
self.h_len = h_len
self.height = height
self.width = width
self.loc_std = loc_std
self.transform_tr, self.transform_te = build_transforms(
self.height,
self.width,
)
assert self.test_mode in [
'train', 'val', 'test'
], 'mode must be one of [train, val or test]'
self.sequences = []
self.data = self._process()
self._cache_flag = False
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--config-file',
type=str,
default='',
help='path to config file')
parser.add_argument('--output_name', type=str, default='model')
parser.add_argument('opts',
default=None,
nargs=argparse.REMAINDER,
help='Modify config options using the command-line')
args = parser.parse_args()
cfg = get_default_config()
cfg.use_gpu = torch.cuda.is_available()
if args.config_file:
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
model = torchreid.models.build_model(name=cfg.model.name,
num_classes=2,
loss=cfg.loss.name,
pretrained=cfg.model.pretrained,
use_gpu=cfg.use_gpu,
dropout_prob=cfg.model.dropout_prob,
feature_dim=cfg.model.feature_dim,
activation=cfg.model.activation,
in_first=cfg.model.in_first)
load_pretrained_weights(model, cfg.model.load_weights)
model.eval()
_, transform = build_transforms(cfg.data.height, cfg.data.width)
input_size = (cfg.data.height, cfg.data.width, 3)
img = np.random.rand(*input_size).astype(np.float32)
img = np.uint8(img * 255)
im = Image.fromarray(img)
blob = transform(im).unsqueeze(0)
torch.onnx.export(model,
blob,
args.output_name + '.onnx',
verbose=True,
export_params=True)
def __init__(
self,
sources=None,
targets=None,
height=256,
width=128,
transforms='random_flip',
norm_mean=None,
norm_std=None,
use_gpu=False,
apply_masks_to_test=False
):
self.source_groups = sources
if self.source_groups is None:
raise ValueError('sources must not be None')
if isinstance(self.source_groups, str):
self.source_groups = [[self.source_groups]]
elif isinstance(self.source_groups, (list, tuple)):
self.source_groups = [[v] if isinstance(v, str) else v for v in self.source_groups]
self.sources = [s for group in self.source_groups for s in group]
self.targets = targets
if self.targets is None:
self.targets = self.sources
if isinstance(self.targets, str):
self.targets = [self.targets]
self.height = height
self.width = width
self.transform_tr, self.transform_te = build_transforms(
self.height,
self.width,
transforms=transforms,
norm_mean=norm_mean,
norm_std=norm_std,
apply_masks_to_test=apply_masks_to_test,
)
self.use_gpu = (torch.cuda.is_available() and use_gpu)
def build_dataset(mode='gallery',
targets=None,
height=192,
width=256,
transforms=None,
norm_mean=None,
norm_std=None,
**kwargs):
_, transform_test = build_transforms(height,
width,
transforms=transforms,
norm_mean=norm_mean,
norm_std=norm_std)
main_target_name = targets[0]
dataset = init_image_dataset(main_target_name,
transform=transform_test,
mode=mode,
verbose=False,
**kwargs)
return dataset
