def __init__(self, checkpoint_dir, features_dir, is_c4net=True):
self.gpu_id = 1
os.environ["CUDA_VISIBLE_DEVICES"] = str(self.gpu_id)
self.num_workers = 8
self.batch_size = 8
self.checkpoint_dir = checkpoint_dir
self.features_dir = Tools.new_dir(features_dir)
if is_c4net:
self.net = C4Net(hid_dim=64, z_dim=64, has_norm=False)
else:
self.net = ResNet12Small(avg_pool=True, drop_rate=0.1)
if "Linux" in platform.platform():
self.data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(self.data_root):
self.data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
self.data_root = "F:\\data\\miniImagenet"
self.data_root = os.path.join(self.data_root, "miniImageNet_png")
Tools.print(self.data_root)
Tools.print(self.features_dir)
pass
def __init__(self,
gpu_id=1,
name=None,
is_conv_4=True,
mn_checkpoint=None,
dataset_name=MyDataset.dataset_name_miniimagenet,
is_check=False):
self.gpu_id = gpu_id
os.environ["CUDA_VISIBLE_DEVICES"] = str(self.gpu_id)
self.name = name
self.is_conv_4 = is_conv_4
self.dataset_name = dataset_name
self.num_way = 5
self.num_shot = 1
self.num_workers = 8
self.episode_size = 15
self.test_episode = 600
self.mn_checkpoint = mn_checkpoint
###############################################################################################
if self.is_conv_4:
self.matching_net, self.batch_size = C4Net(hid_dim=64,
z_dim=64), 64
else:
self.matching_net, self.batch_size = ResNet12Small(
avg_pool=True, drop_rate=0.1), 32
###############################################################################################
self.is_check = is_check
if self.is_check:
self.log_file = None
return
self.log_file = Tools.new_dir(
os.path.join(
"../models_abl/{}/mn/result".format(self.dataset_name),
"{}_{}.txt".format(self.name, Tools.get_format_time())))
###############################################################################################
self.is_png = True
self.data_root = MyDataset.get_data_root(
dataset_name=self.dataset_name, is_png=self.is_png)
_, _, self.transform_test = MyTransforms.get_transform(
dataset_name=self.dataset_name,
has_ic=True,
is_fsl_simple=True,
is_css=False)
###############################################################################################
pass
def __init__(self,
gpu_id=1,
dataset_name=MyDataset.dataset_name_miniimagenet,
is_conv_4=True,
is_res34=True,
is_modify_head=True):
self.gpu_id = gpu_id
os.environ["CUDA_VISIBLE_DEVICES"] = str(self.gpu_id)
self.dataset_name = dataset_name
self.is_conv_4 = is_conv_4
self.is_res34 = is_res34
self.modify_head = is_modify_head
self.num_workers = 8
self.num_way = 5
self.num_shot = 1
self.val_freq = 10
self.episode_size = 15
self.test_episode = 600
self.ic_out_dim = 512
self.ic_ratio = 1
self.learning_rate = 0.01
self.loss_fsl_ratio = 1.0
self.loss_ic_ratio = 1.0
###############################################################################################
self.train_epoch = 1500
self.first_epoch, self.t_epoch = 300, 200
self.adjust_learning_rate = RunnerTool.adjust_learning_rate1
###############################################################################################
###############################################################################################
self.is_png = True
self.data_root = MyDataset.get_data_root(
dataset_name=self.dataset_name, is_png=self.is_png)
self.transform_train_ic, self.transform_train_fsl, self.transform_test = MyTransforms.get_transform(
dataset_name=self.dataset_name,
has_ic=True,
is_fsl_simple=True,
is_css=False)
if self.is_res34:
self.resnet = resnet34
self.ic_net_name = "res34{}".format(
"_head" if self.modify_head else "")
else:
self.resnet = resnet18
self.ic_net_name = "res18{}".format(
"_head" if self.modify_head else "")
pass
if self.is_conv_4:
self.matching_net, self.batch_size, self.e_net_name = C4Net(
hid_dim=64, z_dim=64), 64, "C4"
else:
self.matching_net, self.batch_size, self.e_net_name = ResNet12Small(
avg_pool=True, drop_rate=0.1), 32, "R12S"
###############################################################################################
self.model_name = "{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}{}".format(
self.gpu_id, self.ic_net_name, self.e_net_name, self.train_epoch,
self.batch_size, self.num_way, self.num_shot, self.first_epoch,
self.t_epoch, self.ic_out_dim, self.ic_ratio, self.loss_fsl_ratio,
self.loss_ic_ratio, "_png" if self.is_png else "")
self.time = Tools.get_format_time()
_root_path = "../models_abl/{}/mn".format(self.dataset_name)
self.mn_dir = "{}/{}_{}_mn.pkl".format(_root_path, self.time,
self.model_name)
self.ic_dir = "{}/{}_{}_ic.pkl".format(_root_path, self.time,
self.model_name)
self.log_file = self.ic_dir.replace(".pkl", ".txt")
Tools.print(self.data_root, txt_path=self.log_file)
Tools.print(self.model_name, txt_path=self.log_file)
Tools.print(self.mn_dir, txt_path=self.log_file)
Tools.print(self.ic_dir, txt_path=self.log_file)
pass
class Config(object):
gpu_id = 2
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
num_workers = 32
#######################################################################################
ic_ratio = 1
ic_knn = 100
# ic_out_dim = 2048
ic_out_dim = 1024
ic_val_freq = 10
ic_net, ic_net_name = EncoderC4(), "ICConv4"
ic_learning_rate = 0.01
ic_train_epoch = 1200
ic_first_epoch, ic_t_epoch = 400, 200
ic_batch_size = 64 * 4
ic_adjust_learning_rate = RunnerTool.adjust_learning_rate1
#######################################################################################
###############################################################################################
fsl_num_way = 5
fsl_num_shot = 1
fsl_episode_size = 15
fsl_test_episode = 600
fsl_matching_net, fsl_net_name, fsl_batch_size = C4Net(
hid_dim=64, z_dim=64), "conv4", 96
fsl_learning_rate = 0.01
fsl_batch_size = fsl_batch_size
fsl_val_freq = 10
fsl_train_epoch = 300
fsl_lr_schedule = [150, 250]
###############################################################################################
model_name = "{}_{}_{}_{}_{}_{}_{}_{}_{}_{}".format(
gpu_id, ic_net_name, ic_train_epoch, ic_batch_size, ic_out_dim,
fsl_net_name, fsl_train_epoch, fsl_num_way, fsl_num_shot,
fsl_batch_size)
dataset_name = "omniglot_single"
# dataset_name = "omniglot_rot"
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/UFSL/{}'.format(dataset_name)
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/UFSL/{}'.format(
dataset_name)
if not os.path.isdir(data_root):
data_root = '/home/ubuntu/Dataset/Partition1/ALISURE/Data/UFSL/{}'.format(
dataset_name)
else:
data_root = "F:\\data\\{}".format(dataset_name)
Tools.print(data_root)
_root_path = "../omniglot/models_mn/two_ic_ufsl_2net_res_sgd_acc_duli_nete"
mn_dir = Tools.new_dir("{}/{}_mn.pkl".format(_root_path, model_name))
ic_dir = Tools.new_dir("{}/{}_ic.pkl".format(_root_path, model_name))
# ic_dir_checkpoint = None
# ic_dir_checkpoint = "../omniglot/ic/2_28_ICConv4_64_2048_1_1500_500_200_ic.pkl"
# ic_dir_checkpoint = "../omniglot/ic/3_28_ICConv4_64_2048_1_1600_1000_300_ic.pkl"
ic_dir_checkpoint = "../omniglot/ic/2_28_ICConv4_64_1024_1_1600_1000_300_ic.pkl"
Tools.print(model_name)
pass
def __init__(self):
super().__init__()
self.encoder = C4Net(64, 64)
self.out_dim = 64
pass
class Config(object):
gpu_id = 3
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
num_workers = 16
num_way = 5
num_way_test = 5
num_shot = 1
learning_rate = 0.01
episode_size = 15
test_episode = 600
# batch_size = 64
# train_epoch = 1700
# first_epoch, t_epoch = 500, 200
# adjust_learning_rate = RunnerTool.adjust_learning_rate1
is_png = True
###############################################################################################
baseline_type_list = ["random", "css", "cluster"]
# baseline_type = "css"
# baseline_type = "random"
baseline_type = "cluster"
###############################################################################################
###############################################################################################
# val_freq = 10
# dataset_name = "miniimagenet"
# train_epoch = 300
# first_epoch, t_epoch = 100, 100
# adjust_learning_rate = RunnerTool.adjust_learning_rate2
# net, net_name, batch_size = C4Net(hid_dim=64, z_dim=64, has_norm=False), "conv4", 64
# val_freq = 10
# dataset_name = "miniimagenet"
# train_epoch = 150
# first_epoch, t_epoch = 80, 40
# adjust_learning_rate = RunnerTool.adjust_learning_rate2
# net, net_name, batch_size = ResNet12Small(avg_pool=True, drop_rate=0.1), "res12", 32
###############################################################################################
###############################################################################################
# val_freq = 5
# dataset_name = "tieredimagenet"
# train_epoch = 150
# first_epoch, t_epoch = 80, 40
# adjust_learning_rate = RunnerTool.adjust_learning_rate2
# net, net_name, batch_size = C4Net(hid_dim=64, z_dim=64, has_norm=False), "conv4", 64
# val_freq = 2
# dataset_name = "tieredimagenet"
# # train_epoch = 50
# # first_epoch, t_epoch = 30, 10
# train_epoch = 30
# first_epoch, t_epoch = 16, 8
# adjust_learning_rate = RunnerTool.adjust_learning_rate2
# net, net_name, batch_size = ResNet12Small(avg_pool=True, drop_rate=0.1), "res12", 32
###############################################################################################
###############################################################################################
val_freq = 10
num_way = 10
num_way_test = 5
dataset_name = "omniglot"
train_epoch = 300
first_epoch, t_epoch = 200, 50
adjust_learning_rate = RunnerTool.adjust_learning_rate2
net, net_name, batch_size = C4Net(hid_dim=64, z_dim=64,
has_norm=False), "conv4", 64
###############################################################################################
transform_train, transform_test = MyTransforms.get_transform(
dataset_name=dataset_name,
has_ic=False,
is_fsl_simple=False,
is_css=baseline_type == "css")
model_name = "{}_{}_{}_{}_{}_{}_{}_{}_{}{}".format(
gpu_id, baseline_type, net_name, train_epoch, batch_size, num_way,
num_shot, first_epoch, t_epoch, "_png" if is_png else "")
net_dir = Tools.new_dir("../models_baseline/{}/{}/{}.pkl".format(
dataset_name, baseline_type, model_name))
data_root = MyDataset.get_data_root(dataset_name=dataset_name,
is_png=is_png)
if baseline_type == "cluster":
cluster_path = os.path.join("{}_feature".format(data_root),
"train_cluster.pkl")
Tools.print(model_name)
Tools.print(net_dir)
Tools.print(data_root)
pass