def get_model(options): # Choose the embedding network if options.network == 'ProtoNet': network = ProtoNetEmbedding().cuda() elif options.network == 'R2D2': network = R2D2Embedding().cuda() elif options.network == 'ResNet': if options.dataset == 'miniImageNet' or options.dataset == 'tieredImageNet': network = resnet12(avg_pool=False, drop_rate=0.1, dropblock_size=5).cuda() network = torch.nn.DataParallel(network) #, device_ids=[1, 2]) else: network = resnet12(avg_pool=False, drop_rate=0.1, dropblock_size=2).cuda() else: print("Cannot recognize the network type") assert (False) # Choose the classification head if options.head == 'Subspace': cls_head = ClassificationHead(base_learner='Subspace').cuda() elif options.head == 'ProtoNet': cls_head = ClassificationHead(base_learner='ProtoNet').cuda() elif options.head == 'Ridge': cls_head = ClassificationHead(base_learner='Ridge').cuda() elif options.head == 'R2D2': cls_head = ClassificationHead(base_learner='R2D2').cuda() elif options.head == 'SVM': cls_head = ClassificationHead(base_learner='SVM-CS').cuda() else: print("Cannot recognize the dataset type") assert (False) return (network, cls_head)
def get_model(options): # Choose the embedding network if options.network == 'ProtoNet': network = ProtoNetEmbedding().cuda() elif options.network == 'R2D2': network = R2D2Embedding().cuda() elif options.network == 'R2D2_mixup': network = R2D2Embedding_mixup().cuda() elif options.network == 'ResNet_mixup': network = resnet12_mixup(avg_pool=False, drop_rate=0.1, dropblock_size=2).cuda() elif options.network == 'ResNet': if options.dataset == 'miniImageNet' or options.dataset == 'tieredImageNet': network = resnet12(avg_pool=False, drop_rate=0.1, dropblock_size=5).cuda() network = torch.nn.DataParallel(network) else: network = resnet12(avg_pool=False, drop_rate=0.1, dropblock_size=2).cuda() network = torch.nn.DataParallel(network) else: print("Cannot recognize the network type") assert (False) # Choose the classification head if options.head == 'ProtoNet': cls_head = ClassificationHead(base_learner='ProtoNet').cuda() elif options.head == 'Ridge': cls_head = ClassificationHead(base_learner='Ridge').cuda() elif options.head == 'R2D2': cls_head = R2D2Head().cuda() elif options.head == 'SVM': cls_head = ClassificationHead(base_learner='SVM-CS').cuda() else: print("Cannot recognize the dataset type") assert (False) if options.support_aug and 'mix' in options.support_aug: if options.head == 'R2D2': cls_head_mixup = R2D2Head_Mixup().cuda() elif options.head == 'SVM': cls_head_mixup = ClassificationHead_Mixup( base_learner='SVM-CS').cuda() else: print("Cannot recognize the dataset type") return (network, cls_head, cls_head_mixup) else: return (network, cls_head)
def get_model(options): #return (embedding network, classification head) # Choose the embedding network if options.network == 'Conv4': if options.dataset == 'miniImageNet' or options.dataset == 'tieredImageNet': network = Conv4(avg_pool=True).cuda() else: network = Conv4().cuda() elif options.network == 'ResNet12': if options.dataset == 'miniImageNet' or options.dataset == 'tieredImageNet': network = Resnet12(avg_pool=True, drop_rate=0.1, dropblock_size=5).cuda() else: network = Resnet12(avg_pool=False, drop_rate=0.1, dropblock_size=2).cuda() else: print("Cannot recognize the network type!") assert False # Choose the classification head cls_head = ClassificationHead(base_learner=options.head).cuda() IAM = InverseAttentionModule(options.dim, reduction=options.reduction, dropout=0.5).cuda() device = (options.gpu).split(',') device = [int(s) for s in device] network = torch.nn.DataParallel(network, device_ids=device) IAM = torch.nn.DataParallel(IAM, device_ids=device) return (network, cls_head, IAM)
def get_model(options): # Choose the embedding network # if options.network == 'ProtoNet': # network = ProtoNetEmbedding().cuda() # elif options.network == 'R2D2': # network = R2D2Embedding().cuda() if options.network == 'ResNet': if options.dataset == 'miniImageNet' or options.dataset == 'tieredImageNet': network = resnet12(avg_pool=options.avg, drop_rate=options.drop_rate, dropblock_size=5).cuda() # network = torch.nn.DataParallel(network, device_ids=[0, 1, 2, 3]) # print(os.environ['CUDA_VISIBLE_DEVICES']) # print(list(range(len(options.gpu_ids)))) network = torch.nn.DataParallel(network, device_ids=list( range(len(options.gpu_ids)))) else: network = resnet12(avg_pool=options.avg, drop_rate=options.drop_rate, dropblock_size=2).cuda() network = torch.nn.DataParallel(network, device_ids=list( range(len(options.gpu_ids)))) else: print("Cannot recognize the network type") # Choose the classification head try: if options.scale_const: cls_head = ScheduledClassificationHead( base_learner=options.head, enable_scale=options.scale, scale=options.scale_const, fn=lambda x: options.scale_const, ).cuda() # norm=options.norm, power=options.power).cuda() print('Use const scale {}.'.format(options.scale_const)) elif options.scale_schedule: cls_head = ScheduledClassificationHead( base_learner=options.head, enable_scale=options.scale, scale=5.0, fn=lambda e: 10. if e < 14000 else (20. if e < 16000 else 30. if e < 18000 else (50.)), ).cuda() # norm=options.norm, power=options.power).cuda() print('Use scheduled scale.') else: cls_head = ClassificationHead( base_learner=options.head, enable_scale=options.scale, ).cuda() # norm=options.norm, power=options.power).cuda() print('Use learnable scale') except Exception: print("Cannot recognize the classification head") return (network, cls_head)
def get_model(options): # Choose the embedding network if options.network == 'ProtoNet': network = ProtoNetEmbedding().cuda() elif options.network == 'R2D2': network = R2D2Embedding().cuda() elif options.network == 'ResNet': if options.dataset == 'miniImageNet' or options.dataset == 'tieredImageNet': network = resnet12(avg_pool=False, drop_rate=0.1, dropblock_size=5).cuda() # device_ids = list(range(len(options.gpu.split(',')))) # network = torch.nn.DataParallel(network, device_ids=device_ids) # network = torch.nn.DataParallel(network, device_ids=[0, 1, 2, 3]) else: network = resnet12(avg_pool=False, drop_rate=0.1, dropblock_size=2).cuda() # device_ids = list(range(len(options.gpu.split(',')))) # network = torch.nn.DataParallel(network, device_ids=device_ids) elif options.network == 'ResNetRFS': if 'imagenet' in opt.dataset.lower(): network = resnet12_rfs(avg_pool=True, drop_rate=0.1, dropblock_size=5).cuda() else: network = resnet12_rfs(avg_pool=True, drop_rate=0.1, dropblock_size=2).cuda() # device_ids = list(range(len(options.gpu.split(',')))) # network = torch.nn.DataParallel(network, device_ids=device_ids) else: print ("Cannot recognize the network type") assert(False) # Choose the classification head if opt.head == 'ProtoNet': cls_head = ClassificationHead(base_learner='ProtoNet').cuda() elif opt.head == 'Ridge': cls_head = ClassificationHead(base_learner='Ridge').cuda() elif opt.head == 'R2D2': cls_head = ClassificationHead(base_learner='R2D2').cuda() elif opt.head == 'SVM' or 'LR': cls_head = ClassificationHead(base_learner='SVM-CS').cuda() elif options.head == 'SVM-BiP': cls_head = ClassificationHead(base_learner='SVM-CS-BiP').cuda() else: print ("Cannot recognize the classification head type") assert(False) return (network, cls_head)
def get_model(options): # Choose the embedding network if options.network == 'ProtoNet': network = ProtoNetEmbedding().to(options.device) elif options.network == 'ResNet12': network = torch.nn.DataParallel( resnet12(options.device, avg_pool=False, drop_rate=.1, dropblock_size=2).to(options.device)) elif options.network == 'ResNet18': network = torch.nn.DataParallel( resnet18(pretrained=False).to(options.device)) else: print("Cannot recognize the network type") assert (False) # Set the classification head cls_head = ClassificationHead(options.device).to(options.device) return (network, cls_head)
def get_model(options): # Choose the embedding network if options.network == 'ProtoNet': # 256 dimensional network = ProtoNetEmbedding().cuda() elif options.network == 'R2D2': # 8192 dimensional network = R2D2Embedding().cuda() elif options.network == 'WideResNet_DC': if options.dataset == 'miniImageNet' or options.dataset == 'tieredImageNet': if options.aws == 1: network = WideResNet(28, widen_factor=10, dropRate=0.1, avgpool_param=21).cuda() network = torch.nn.DataParallel(network, device_ids=[0, 1, 2, 3]) else: network = WideResNet(28, widen_factor=10, dropRate=0.1, avgpool_param=21).cuda() network = torch.nn.DataParallel(network, device_ids=[0, 1, 2, 3]) else: if options.aws == 1: network = WideResNet(28, widen_factor=10, dropRate=0.1, avgpool_param=8).cuda() network = torch.nn.DataParallel(network, device_ids=[0, 1, 2, 3]) else: network = WideResNet(28, widen_factor=10, dropRate=0.1, avgpool_param=8).cuda() network = torch.nn.DataParallel(network, device_ids=[0, 1, 2, 3]) elif options.network == 'ResNet_DC': # 2560 dimensional if options.dataset == 'miniImageNet' or options.dataset == 'tieredImageNet': if options.aws == 1: network = resnet12(avg_pool=True, drop_rate=0.1, dropblock_size=5, avgpool_param=5).cuda() network = torch.nn.DataParallel(network, device_ids=[0, 1, 2, 3]) else: network = resnet12(avg_pool=True, drop_rate=0.1, dropblock_size=5, avgpool_param=5).cuda() network = torch.nn.DataParallel(network) else: if options.aws == 1: network = resnet12(avg_pool=True, drop_rate=0.1, dropblock_size=2, avgpool_param=2).cuda() network = torch.nn.DataParallel(network, device_ids=[0, 1, 2, 3]) else: network = resnet12(avg_pool=True, drop_rate=0.1, dropblock_size=2, avgpool_param=2).cuda() network = torch.nn.DataParallel(network) else: print("Cannot recognize the network type") assert (False) # Choose the classification head if options.head == 'ProtoNet': cls_head = ClassificationHead(base_learner='ProtoNet').cuda() elif options.head == 'Ridge': cls_head = ClassificationHead(base_learner='Ridge').cuda() elif options.head == 'R2D2': cls_head = ClassificationHead(base_learner='R2D2').cuda() elif options.head == 'SVM': cls_head = ClassificationHead(base_learner='SVM-CS').cuda() elif options.head == 'FIML': cls_head = dimp_norm_init_shannon_hingeL2Loss( num_iter=options.steepest_descent_iter, norm_feat=options.norm_feat, entropy_weight=options.entropy_weight, entropy_temp=options.entropy_temp, learn_entropy_weights=options.learn_entropy_weights, learn_entropy_temp=options.learn_entropy_temp, learn_weights=options.learn_weights, pos_weight=options.pos_weight, neg_weight=options.neg_weight, learn_slope=options.learn_slope, pos_lrelu_slope=options.pos_lrelu_slope, neg_lrelu_slope=options.neg_lrelu_slope, learn_spatial_weight=options.learn_inner_spatial_weight, dc_factor=options.dc_factor) else: print("Cannot recognize the dataset type") assert (False) return (network, cls_head)
def get_model(options): # Choose the embedding network if options.network == 'ProtoNet': network = ProtoNetEmbedding().cuda() elif options.network == 'R2D2': network = R2D2Embedding().cuda() elif options.network == 'ResNet': if 'imagenet' in options.dataset.lower(): network = resnet12(avg_pool=False, drop_rate=0.1, dropblock_size=5).cuda() else: network = resnet12(avg_pool=False, drop_rate=0.1, dropblock_size=2).cuda() device_ids = list(range(len(options.gpu.split(',')))) network = torch.nn.DataParallel(network, device_ids=device_ids) elif options.network == 'ResNetRFS': if 'imagenet' in opt.dataset.lower(): network = resnet12_rfs(avg_pool=True, drop_rate=0.1, dropblock_size=5).cuda() else: network = resnet12_rfs(avg_pool=True, drop_rate=0.1, dropblock_size=2).cuda() device_ids = list(range(len(options.gpu.split(',')))) network = torch.nn.DataParallel(network, device_ids=device_ids) elif options.network == 'ResNet_FiLM': film_act = None if options.no_film_activation else F.leaky_relu if 'imagenet' in options.dataset.lower(): network = resnet12_film( avg_pool=False, drop_rate=0.1, dropblock_size=5, film_indim=opt.film_indim, film_alpha=1.0, film_act=film_act, final_relu=(not opt.no_final_relu), film_normalize=opt.film_normalize, dual_BN=options.dual_BN).cuda() options.film_preprocess_input_dim = 16000 else: network = resnet12_film( avg_pool=False, drop_rate=0.1, dropblock_size=2, film_indim=options.film_indim, film_alpha=1.0, film_act=film_act, final_relu=(not opt.no_final_relu), film_normalize=opt.film_normalize, dual_BN=options.dual_BN).cuda() device_ids = list(range(len(options.gpu.split(',')))) network = torch.nn.DataParallel(network, device_ids=device_ids) elif options.network == 'ResNetRFS_FiLM': film_act = None if options.no_film_activation else F.leaky_relu if 'imagenet' in opt.dataset.lower(): network = resnet12_rfs_film( avg_pool=True, drop_rate=0.1, dropblock_size=5, film_indim=640, film_alpha=1.0, film_act=film_act, final_relu=(not options.no_final_relu), film_normalize=options.film_normalize, dual_BN=options.dual_BN).cuda() else: network = resnet12_rfs_film( avg_pool=True, drop_rate=0.1, dropblock_size=2, film_indim=640, film_alpha=1.0, film_act=film_act, final_relu=(not options.no_final_relu), film_normalize=options.film_normalize, dual_BN=options.dual_BN).cuda() device_ids = list(range(len(options.gpu.split(',')))) network = torch.nn.DataParallel(network, device_ids=device_ids) else: print("Cannot recognize the network type") assert False # Choose the classification head if opt.head == 'ProtoNet': cls_head = ClassificationHead(base_learner='ProtoNet').cuda() elif opt.head == 'Ridge': cls_head = ClassificationHead(base_learner='Ridge').cuda() elif opt.head == 'R2D2': cls_head = ClassificationHead(base_learner='R2D2').cuda() elif opt.head == 'SVM' or opt.head == 'LR': cls_head = ClassificationHead(base_learner='SVM-CS').cuda() elif options.head == 'SVM-BiP': cls_head = ClassificationHead(base_learner='SVM-CS-BiP').cuda() else: print("Cannot recognize the classification head type") assert False return network, cls_head
def __init__(self): super(TaskEmbedding_FiLM_Entropy_SVM, self).__init__() self.cls_head = ClassificationHead(base_learner='SVM-CS')
def __init__(self): super(TaskEmbedding_Entropy_RidgeHead, self).__init__() self.cls_head = ClassificationHead(base_learner='Ridge')
def __init__(self): super(TaskEmbedding_FiLM_SVM_OnW, self).__init__() self.cls_head = ClassificationHead(base_learner='SVM-CS-OnW')
def __init__(self): super(TaskEmbedding_Cat_SVM_WGrad, self).__init__() self.cls_head = ClassificationHead(base_learner='SVM-CS-WNorm')