def make_model(): resnet50_backbone = get_backbone() loss_fn = RetinaNetLoss(num_classes) model = RetinaNet(num_classes, resnet50_backbone) optimizer = tf.optimizers.SGD(learning_rate=learning_rate_fn, momentum=0.9) model.compile(loss=loss_fn, optimizer=optimizer) return model
def __init__(self, backbone=None, **kwargs): super(FeaturePyramid, self).__init__(name="FeaturePyramid", **kwargs) self.backbone = backbone if backbone else get_backbone() self.conv_c3_1x1 = tf.keras.layers.Conv2D(256, 1, 1, "same") self.conv_c4_1x1 = tf.keras.layers.Conv2D(256, 1, 1, "same") self.conv_c5_1x1 = tf.keras.layers.Conv2D(256, 1, 1, "same") self.conv_c3_3x3 = tf.keras.layers.Conv2D(256, 3, 1, "same") self.conv_c4_3x3 = tf.keras.layers.Conv2D(256, 3, 1, "same") self.conv_c5_3x3 = tf.keras.layers.Conv2D(256, 3, 1, "same") self.conv_c6_3x3 = tf.keras.layers.Conv2D(256, 3, 2, "same") self.conv_c7_3x3 = tf.keras.layers.Conv2D(256, 3, 2, "same") self.upsample_2x = tf.keras.layers.UpSampling2D(2)
def __init__(self, cfg): super(FineTuneNet, self).__init__() trunk = cfg.MODEL.TRUNK num_classes = cfg.MODEL.FINETUNING.NUM_CLASSES assert num_classes > 0 and isinstance( num_classes, int ), 'Please give a positive integer for the number of classes in the finetuning stage' p_dropout = cfg.MODEL.FINETUNING.DROPOUT self.backbone, backbone_channels = get_backbone(trunk) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.dropout = nn.Dropout(p=p_dropout) self.fc = nn.Linear(backbone_channels, num_classes)
def __init__(self, cfg): super(PreTrainNet, self).__init__() trunk = cfg.MODEL.TRUNK fc_dim = cfg.MODEL.PRETRAINING.FC_DIM self.backbone, backbone_channels = get_backbone(trunk) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.fc_contrastive = nn.Linear(backbone_channels, fc_dim) self.l2norm = Normalise(2) self.fc_rotation_1 = nn.Linear(backbone_channels, 200) self.bn_rotation_1 = nn.BatchNorm1d(num_features=200) self.fc_rotation_2 = nn.Linear(200, 200) self.bn_rotation_2 = nn.BatchNorm1d(num_features=200) self.fc_rotation_3 = nn.Linear(200, 4)
shuffle=True, num_workers=config.num_workers, pin_memory=True, drop_last=True) test_loader = torch.utils.data.DataLoader(dataset=test_set, batch_size=config.batch_size, shuffle=False, num_workers=config.num_workers, pin_memory=True, drop_last=True) print("Batches train set: {}".format(len(train_loader))) print("Barches test set: {}".format(len(test_loader))) # model backbone = get_backbone(train_config.backbone) model = SimSiam(backbone, train_config.projector_args, train_config.predictor_args) msg = model.load_state_dict(ckpt["state_dict"], strict=True) print("Loading weights: {}".format(msg)) model = model.encoder model = model.to(config.device) # classifier classifier = nn.Linear(in_features=train_config.projector_args["out_dim"], out_features=len(test_set.classes), bias=True) classifier = classifier.to(config.device) optimizer = get_optimizer(config.optimizer, classifier, config.optimizer_args)
def main(): # data normalization input_size = 224 normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # data loaders kwargs = {'num_workers': 8, 'pin_memory': True} if args.cuda else {} if args.da: train_transforms = transforms.Compose([ random_transform, transforms.ToPILImage(), transforms.Resize((input_size, input_size)), transforms.ToTensor(), normalize ]) else: train_transforms = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((input_size, input_size)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize ]) test_transforms = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((input_size, input_size)), transforms.ToTensor(), normalize ]) train_loader = torch.utils.data.DataLoader(DataLoader(df_train, train_transforms, root=args.data_dir, mode=args.mode), batch_size=args.batch_size, shuffle=True, **kwargs) test_loader = torch.utils.data.DataLoader(DataLoader(df_gal, test_transforms, root=args.data_dir, mode=args.mode), batch_size=args.batch_size, shuffle=False, **kwargs) # instanciate the models output_shape, backbone = get_backbone(args) embed = LinearProjection(output_shape, args.dim_embed) model = ConvNet(backbone, embed) # instanciate the proxies fsem = get_semantic_fname(args.word) path_semantic = os.path.join('aux', 'Semantic', args.dataset, fsem) train_proxies = get_proxies(path_semantic, df_train['cat'].cat.categories) test_proxies = get_proxies(path_semantic, df_gal['cat'].cat.categories) train_proxynet = ProxyNet(args.n_classes, args.dim_embed, proxies=torch.from_numpy(train_proxies)) test_proxynet = ProxyNet(args.n_classes_gal, args.dim_embed, proxies=torch.from_numpy(test_proxies)) # criterion criterion = ProxyLoss(args.temperature) if args.multi_gpu: model = nn.DataParallel(model) if args.cuda: backbone.cuda() embed.cuda() model.cuda() train_proxynet.cuda() test_proxynet.cuda() parameters_set = [] low_layers = [] upper_layers = [] for c in backbone.children(): low_layers.extend(list(c.parameters())) for c in embed.children(): upper_layers.extend(list(c.parameters())) parameters_set.append({ 'params': low_layers, 'lr': args.lr * args.factor_lower }) parameters_set.append({'params': upper_layers, 'lr': args.lr * 1.}) optimizer = optim.SGD(parameters_set, lr=args.lr, momentum=0.9, nesterov=True, weight_decay=args.wd) n_parameters = sum([p.data.nelement() for p in model.parameters()]) print(' + Number of params: {}'.format(n_parameters)) scheduler = CosineAnnealingLR(optimizer, args.epochs * len(train_loader), eta_min=3e-6) print('Starting training...') for epoch in range(args.start_epoch, args.epochs + 1): # update learning rate scheduler.step() # train for one epoch train(train_loader, model, train_proxynet.proxies.weight, criterion, optimizer, epoch, scheduler) val_acc = evaluate(test_loader, model, test_proxynet.proxies.weight, criterion) # saving if epoch == args.epochs: save_checkpoint({'epoch': epoch, 'state_dict': model.state_dict()}) print('\nResults on test set (end of training)') write_logs('\nResults on test set (end of training)') test_acc = evaluate(test_loader, model, test_proxynet.proxies.weight, criterion)
def main(): # data normalization input_size = 224 normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # data loaders kwargs = {'num_workers': 8, 'pin_memory': True} if args.cuda else {} test_transforms = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((input_size, input_size)), transforms.ToTensor(), normalize ]) feats = {} labels = {} for domain in ['im', 'sk']: key = '_'.join([domain, 'model_path']) dirname = os.path.dirname(args.__dict__[key]) fpath = os.path.join(dirname, 'features.npz') results_path = os.path.join(dirname, 'results.txt') if os.path.isfile(fpath) and args.rewrite is False: data = np.load(fpath) feats[domain] = data['features'] labels[domain] = data['labels'] txt = ('Domain (%s): Acc %.2f' % (domain, data['acc'] * 100.)) print(txt) write_logs(txt, results_path) df_gal = splits[domain]['gal'] fsem = get_semantic_fname(args.word) path_semantic = os.path.join('aux', 'Semantic', args.dataset, fsem) test_proxies = get_proxies(path_semantic, df_gal['cat'].cat.categories) else: df_gal = splits[domain]['gal'] test_loader = torch.utils.data.DataLoader( DataLoader(df_gal, test_transforms, root=args.data_dir, mode=domain), batch_size=args.batch_size * 10, shuffle=False, **kwargs) # instanciate the models output_shape, backbone = get_backbone(args) embed = LinearProjection(output_shape, args.dim_embed) model = ConvNet(backbone, embed) # instanciate the proxies fsem = get_semantic_fname(args.word) path_semantic = os.path.join('aux', 'Semantic', args.dataset, fsem) test_proxies = get_proxies(path_semantic, df_gal['cat'].cat.categories) test_proxynet = ProxyNet(args.n_classes_gal, args.dim_embed, proxies=torch.from_numpy(test_proxies)) # criterion criterion = ProxyLoss(args.temperature) if args.multi_gpu: model = nn.DataParallel(model) # loading checkpoint = torch.load(args.__dict__[key]) model.load_state_dict(checkpoint['state_dict']) txt = ("\n=> loaded checkpoint '{}' (epoch {})".format( args.__dict__[key], checkpoint['epoch'])) print(txt) write_logs(txt, results_path) if args.cuda: backbone.cuda() embed.cuda() model.cuda() test_proxynet.cuda() txt = 'Extracting testing set (%s)...' % (domain) print(txt) x, y, acc = extract_predict(test_loader, model, test_proxynet.proxies.weight, criterion) feats[domain] = x labels[domain] = y np.savez(fpath, features=feats[domain], labels=labels[domain], acc=acc) fpath_train = os.path.join(dirname, 'features_train.npz') if args.train and not os.path.isfile(fpath_train): df_train = splits[domain]['train'] train_loader = torch.utils.data.DataLoader( DataLoader(df_train, test_transforms, root=args.data_dir, mode=domain), batch_size=args.batch_size * 10, shuffle=False, **kwargs) train_proxies = get_proxies(path_semantic, df_train['cat'].cat.categories) train_proxynet = ProxyNet( args.n_classes_gal, args.dim_embed, proxies=torch.from_numpy(train_proxies)) train_proxynet.cuda() txt = 'Extracting training set (%s)...' % (domain) print(txt) x, y, _ = extract_predict(train_loader, model, train_proxynet.proxies.weight, criterion) fpath = os.path.join(dirname, 'features_train.npz') np.savez(fpath, features=feats[domain], features_train=x, labels=labels[domain], labels_train=y, acc=acc) txt = ('Domain (%s): Acc %.2f' % (domain, acc * 100.)) print(txt) write_logs(txt, results_path) if args.shape: print('\nRetrieval per model') new_feat_im, new_labels_im = average_views(splits['im']['test'], feats['im'], labels['im']) idx = retrieve(feats['sk'], new_feat_im) metrics = score_shape(labels['sk'], new_labels_im, idx) names = ['NN', 'FT', 'ST', 'E', 'nDCG', 'mAP'] txt = [('%s %.3f' % (name, value)) for name, value in zip(names, metrics)] txt = '\t'.join(txt) print(txt) write_logs(txt, results_path) print('\nRetrieval per model with refinement') alpha = 0.4 g_sk_x = KNN(feats['sk'], new_feat_im, K=1, mode='ones') new_sk_x = slerp(alpha, L2norm(feats['sk']), L2norm(g_sk_x)) idx = retrieve(new_sk_x, new_feat_im) metrics = score_shape(labels['sk'], new_labels_im, idx) names = ['NN', 'FT', 'ST', 'E', 'nDCG', 'mAP'] txt = [('%s %.3f' % (name, value)) for name, value in zip(names, metrics)] txt = '\t'.join(txt) print(txt) write_logs(txt, results_path) else: print('\nRetrieval') txt = evaluate(feats['im'], labels['im'], feats['sk'], labels['sk']) print(txt) write_logs(txt, results_path) print('\nRetrieval with refinement') if args.overwrite: alpha = 0.7 else: alpha = 0.4 g_sk_x = KNN(feats['sk'], feats['im'], K=1, mode='ones') new_sk_x = slerp(alpha, L2norm(feats['sk']), L2norm(g_sk_x)) txt = evaluate(feats['im'], labels['im'], new_sk_x, labels['sk']) print(txt) write_logs(txt, results_path)
def main(): # data normalization normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # data loaders kwargs = {'num_workers': 8, 'pin_memory': True} if args.cuda else {} test_transforms = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((224, 224)), transforms.ToTensor(), normalize ]) feats = {} labels = {} for domain in ['im', 'sk']: key = '_'.join([domain, 'model_path']) dirname = os.path.dirname(args.__dict__[key]) fpath = os.path.join(dirname, 'features.npz') results_path = os.path.join(dirname, 'results.txt') if os.path.isfile(fpath) and args.rewrite is False: data = np.load(fpath) feats[domain] = data['features'] labels[domain] = data['labels'] txt = ('Domain (%s): Acc %.2f' % (domain, data['acc'] * 100.)) print(txt) write_logs(txt, results_path) df_gal = splits[domain]['test'] fsem = get_semantic_fname(args.word) path_semantic = os.path.join('aux', 'Semantic', args.dataset, fsem) test_proxies = get_proxies(path_semantic, df_gal['cat'].cat.categories) else: df_gal = splits[domain]['test'] test_loader = torch.utils.data.DataLoader( DataLoader(df_gal, test_transforms, root=args.data_dir, mode=domain), batch_size=args.batch_size * 1, shuffle=False, **kwargs) # instanciate the models output_shape, backbone = get_backbone(args) embed = LinearProjection(output_shape, args.dim_embed) model = ConvNet(backbone, embed) # instanciate the proxies fsem = get_semantic_fname(args.word) path_semantic = os.path.join('aux', 'Semantic', args.dataset, fsem) test_proxies = get_proxies(path_semantic, df_gal['cat'].cat.categories) test_proxynet = ProxyNet(args.n_classes_gal, args.dim_embed, proxies=torch.from_numpy(test_proxies)) # criterion criterion = ProxyLoss(args.temperature) if args.multi_gpu: model = nn.DataParallel(model) # loading checkpoint = torch.load(args.__dict__[key]) model.load_state_dict(checkpoint['state_dict']) txt = ("\n=> loaded checkpoint '{}' (epoch {})".format( args.__dict__[key], checkpoint['epoch'])) print(txt) if args.cuda: backbone.cuda() embed.cuda() model.cuda() test_proxynet.cuda() txt = 'Extracting testing set (%s)...' % (domain) print(txt) x, y, acc = extract_predict(test_loader, model, test_proxynet.proxies.weight, criterion) feats[domain] = x labels[domain] = y np.savez(fpath, features=feats[domain], labels=labels[domain], acc=acc) txt = ('Domain (%s): Acc %.2f' % (domain, acc * 100.)) print(txt) print('\nFew-Shot') fs(feats, labels, test_proxies)