def inference_ss_train(self, model_file_name=None, data_loader=None, save_path=None):
if model_file_name is not None:
Tools.print("Load model form {}".format(model_file_name), txt_path=self.config.ss_save_result_txt)
self.load_model(model_file_name)
pass
final_save_path = Tools.new_dir("{}_final".format(save_path))
self.net.eval()
with torch.no_grad():
for i, (inputs, labels, image_info_list) in tqdm(enumerate(data_loader), total=len(data_loader)):
assert len(image_info_list) == 1
# 标签
basename = image_info_list[0].split("Data/DET/")[1]
final_name = os.path.join(final_save_path, basename.replace(".JPEG", ".png"))
final_name = Tools.new_dir(final_name)
if os.path.exists(final_name):
continue
# 预测
outputs = self.net(inputs[0].float().cuda()).cpu()
preds = outputs.max(dim=1)[1].numpy()
if save_path:
Image.open(image_info_list[0]).convert("RGB").save(
Tools.new_dir(os.path.join(save_path, basename)))
DataUtil.gray_to_color(np.asarray(preds[0], dtype=np.uint8)).save(
os.path.join(save_path, basename.replace(".JPEG", ".png")))
Image.fromarray(np.asarray(preds[0], dtype=np.uint8)).save(final_name)
pass
pass
pass
pass
class Config(object):
gpu_id = 3
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
num_workers = 8
num_way = 5
num_shot = 1
batch_size = 64
val_freq = 10
episode_size = 15
test_episode = 600
hid_dim = 64
z_dim = 64
matching_net = MatchingNet(hid_dim=hid_dim, z_dim=z_dim)
# ic
ic_out_dim = 512
ic_ratio = 1
learning_rate = 0.01
loss_fsl_ratio = 1.0
loss_ic_ratio = 1.0
train_epoch = 2100
first_epoch, t_epoch = 500, 200
adjust_learning_rate = RunnerTool.adjust_learning_rate1
###############################################################################################
is_png = True
# is_png = False
# resnet = resnet18
resnet = resnet34
# modify_head = False
modify_head = True
###############################################################################################
model_name = "{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}{}{}".format(
gpu_id, train_epoch, batch_size, num_way, num_shot, first_epoch, t_epoch, ic_out_dim, ic_ratio,
loss_fsl_ratio, loss_ic_ratio, "_head" if modify_head else "", "_png" if is_png else "")
Tools.print(model_name)
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
data_root = os.path.join(data_root, "miniImageNet_png") if is_png else data_root
Tools.print(data_root)
_root_path = "../models_mn/two_ic_ufsl_2net_res_sgd_acc_duli"
mn_dir = Tools.new_dir("{}/{}_mn.pkl".format(_root_path, model_name))
ic_dir = Tools.new_dir("{}/{}_ic.pkl".format(_root_path, model_name))
pass
class Config(object):
gpu_id = 2
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
num_workers = 8
episode_size = 15
test_episode = 600
test_avg_num = 5
feature_encoder, relation_network = CNNEncoder(), RelationNetwork()
# model_path = "../models/two_ic_ufsl_2net_res_sgd_acc"
# model_fe_name = "0_2100_64_5_1_500_200_512_1_1.0_1.0_fe_5way_1shot.pkl"
# model_rn_name = "0_2100_64_5_1_500_200_512_1_1.0_1.0_rn_5way_1shot.pkl"
model_path = "../models/two_ic_ufsl_2net_res_sgd_acc_duli"
model_fe_name = "2_2100_64_5_1_500_200_512_1_1.0_1.0_fe_5way_1shot.pkl"
model_rn_name = "2_2100_64_5_1_500_200_512_1_1.0_1.0_rn_5way_1shot.pkl"
fe_dir = Tools.new_dir(os.path.join(model_path, model_fe_name))
rn_dir = Tools.new_dir(os.path.join(model_path, model_rn_name))
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
pass
class Config(object):
os.environ["CUDA_VISIBLE_DEVICES"] = "3"
num_workers = 8
num_way = 5
num_shot = 1
batch_size = 64
test_avg_num = 5
MEAN_PIXEL = [x / 255.0 for x in [120.39586422, 115.59361427, 104.54012653]]
STD_PIXEL = [x / 255.0 for x in [70.68188272, 68.27635443, 72.54505529]]
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
# model_path = "ic_fsl"
# model_fe_name = "2_64_5_1_fe_5way_1shot.pkl"
# model_rn_name = "2_64_5_1_rn_5way_1shot.pkl"
# fe_dir = Tools.new_dir("../models/{}/{}".format(model_path, model_fe_name))
# rn_dir = Tools.new_dir("../models/{}/{}".format(model_path, model_rn_name))
model_path = "fsl_old"
model_fe_name = "1_fe_5way_1shot.pkl"
model_rn_name = "1_rn_5way_1shot.pkl"
fe_dir = Tools.new_dir("../models/{}/{}".format(model_path, model_fe_name))
rn_dir = Tools.new_dir("../models/{}/{}".format(model_path, model_rn_name))
pass
def __init__(self, split="all", class_id=None, is_l2norm=True, result_dir_name=None, png_name=None, sample=None):
self.title = "vis"
self.split = split
self.is_l2norm = is_l2norm
self.class_id = class_id
self.sample = sample
current_time = datetime.now().strftime('%b%d_%H-%M-%S')# or
self.vis_dir = "/home/test/Documents/kbzhao/IC/IC_result/3_resnet_34_64_512_1_2100_500_200"
self.result_pkl = Tools.new_dir(os.path.join(self.vis_dir, "fig_final_new", "{}_{}{}.pkl".format(
self.split, "l2norm" if self.is_l2norm else "logits",
"" if png_name is None else "_{}".format(png_name))))
self.result_png = self.result_pkl[:-4] + f"{current_time}.png"
split_path = os.path.split(self.result_png)
self.result_png = Tools.new_dir(os.path.join(split_path[0], result_dir_name, split_path[1]))
if self.split == "all":
self.feature_dir_list = [os.path.join(self.vis_dir, "train.pkl"),
os.path.join(self.vis_dir, "test.pkl"),
os.path.join(self.vis_dir, "val.pkl")]
else:
self.feature_dir = os.path.join(self.vis_dir, "{}.pkl".format(self.split))
pass
pass
class Config(object):
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
# train_epoch = 300
train_epoch = 180
learning_rate = 0.001
num_workers = 8
val_freq = 10
num_way = 5
num_shot = 1
batch_size = 64
episode_size = 15
test_episode = 600
feature_encoder, relation_network = CNNEncoder(), RelationNetwork()
# feature_encoder, relation_network = CNNEncoder1(), RelationNetwork1()
model_name = "{}_{}_{}_{}".format(train_epoch, batch_size, num_way,
num_shot)
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
fe_dir = Tools.new_dir("../models/fsl/{}_fe_{}way_{}shot.pkl".format(
model_name, num_way, num_shot))
rn_dir = Tools.new_dir("../models/fsl/{}_rn_{}way_{}shot.pkl".format(
model_name, num_way, num_shot))
pass
class Config(object):
gpu_id = 2
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
num_workers = 8
batch_size = 8
resnet, vggnet, net_name = resnet18, None, "resnet_18"
# resnet, vggnet, net_name = resnet34, None, "resnet_34"
# resnet, vggnet, net_name = resnet50, None, "resnet_50"
# resnet, vggnet, net_name = None, vgg16_bn, "vgg16_bn"
modify_head = False
# modify_head = True
# ic
ic_out_dim = 512
ic_dir = "../cub/models/ic_res_xx/2_resnet_18_64_512_1_2100_500_200_False_ic.pkl"
vis_dir = Tools.new_dir(
"../vis/CUB/ic_res_xx/2_resnet_18_64_512_1_2100_500_200_False_ic")
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/UFSL/CUB'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/UFSL/CUB'
else:
data_root = "F:\\data\\CUB"
data_root = os.path.join(data_root, "CUBSeg")
vis_dir = Tools.new_dir(
"../vis/CUBSeg/ic_res_xx/2_resnet_18_64_512_1_2100_500_200_False_ic")
Tools.print(data_root)
pass
class Config(object):
gpu_id = 0
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
num_workers = 16
num_way = 5
num_shot = 1
# batch_size = 64
val_freq = 20
episode_size = 15
test_episode = 600
ic_ratio = 1
knn = 50
learning_rate = 0.01
loss_fsl_ratio = 1.0
loss_ic_ratio = 1.0
###############################################################################################
# resnet = resnet18
resnet = resnet34
# modify_head = False
modify_head = True
# matching_net, net_name, batch_size = MatchingNet(hid_dim=64, z_dim=64), "conv4", 64
matching_net, net_name, batch_size = ResNet12Small(avg_pool=True, drop_rate=0.1), "resnet12", 32
ic_times = 2
ic_out_dim = 512
train_epoch = 1200
first_epoch, t_epoch = 400, 200
adjust_learning_rate = RunnerTool.adjust_learning_rate1
###############################################################################################
model_name = "{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}{}".format(
gpu_id, net_name, train_epoch, batch_size, num_way, num_shot, first_epoch, t_epoch,
ic_out_dim, ic_ratio, loss_fsl_ratio, loss_ic_ratio, ic_times, "_head" if modify_head else "")
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/UFSL/CUB'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/UFSL/CUB'
else:
data_root = "F:\\data\\CUB"
data_root = os.path.join(data_root, "CUBSeg")
_root_path = "../cub/models_mn/two_ic_ufsl_2net_res_sgd_acc_duli"
mn_dir = Tools.new_dir("{}/{}_mn.pkl".format(_root_path, model_name))
ic_dir = Tools.new_dir("{}/{}_ic.pkl".format(_root_path, model_name))
Tools.print(model_name)
Tools.print(data_root)
pass
def inference_crf(self, dataset, logits_path):
logit_file_path = Tools.new_dir("{}_logit".format(logits_path))
crf_file_path = Tools.new_dir("{}_crf".format(logits_path))
crf_final_file_path = Tools.new_dir("{}_crf_final".format(logits_path))
postprocessor = DenseCRF()
n_jobs = multiprocessing.cpu_count()
def process(i):
image_info, label_info = dataset.__getitem__(i)
label = Image.fromarray(np.zeros_like(np.asarray(Image.open(image_info)))).convert("L") \
if label_info == 1 else Image.open(label_info)
basename = os.path.basename(image_info)
im = Image.open(image_info)
logit = np.load(
os.path.join(logit_file_path, basename.replace(".jpg",
".npy")))
ori_size = (im.size[1], im.size[0])
crf_size = (logit.shape[1], logit.shape[2])
logit_tensor = torch.FloatTensor(logit)[None, ...]
logit_tensor = self._up_to_target(logit_tensor,
target_size=crf_size)
prob_one = F.softmax(logit_tensor, dim=1)[0].numpy()
prob_crf = postprocessor(
np.array(im.resize((crf_size[1], crf_size[0]))), prob_one)
prob_crf_resize = self._up_to_target(
torch.FloatTensor(prob_crf)[None, ...], target_size=ori_size)
result = np.argmax(prob_crf_resize[0].numpy(), axis=0)
# save
im.save(os.path.join(crf_file_path, basename))
DataUtil.gray_to_color(np.asarray(label, dtype=np.uint8)).save(
os.path.join(crf_file_path, basename.replace(".jpg",
"_l.png")))
DataUtil.gray_to_color(np.asarray(result, dtype=np.uint8)).save(
os.path.join(crf_file_path, basename.replace(".jpg", ".png")))
Image.fromarray(np.asarray(result, dtype=np.uint8)).save(
os.path.join(crf_final_file_path,
basename.replace(".jpg", ".png")))
return result, np.array(label)
results = joblib.Parallel(n_jobs=n_jobs,
verbose=10,
pre_dispatch="all")([
joblib.delayed(process)(i)
for i in range(len(dataset))
])
metrics = StreamSegMetrics(self.config.ss_num_classes)
for preds, targets in results:
metrics.update(targets, preds)
Tools.print("{}".format(metrics.to_str(metrics.get_results())))
Tools.print()
pass
def _set_dir(model_name, dataset_name, gpu_id, out_dir):
_file_name = "{}_{}_GPU{}_{}".format(
model_name, dataset_name, gpu_id,
time.strftime('%Hh%Mm%Ss_on_%b_%d_%Y'))
root_log_dir = Tools.new_dir("{}/logs/{}".format(out_dir, _file_name))
root_ckpt_dir = Tools.new_dir("{}/checkpoints/{}".format(
out_dir, _file_name))
return root_log_dir, root_ckpt_dir
def __init__(self,
run_name,
batch_size,
max_epochs,
data,
net,
has_weight_decay=True,
log_dir='./logs',
model_dir="./models",
model_name="./c3d_ucf_model",
pre_train=None):
self.run_name = run_name
self.model_name = model_name
self.model_dir = Tools.new_dir(os.path.join(model_dir, self.run_name))
self.checkpoint_path = os.path.join(self.model_dir, self.model_name)
self.log_dir = Tools.new_dir(os.path.join(log_dir, self.run_name))
self.pre_train = pre_train
self.data = data
self.batch_size = batch_size
self.max_epochs = max_epochs
self.has_weight_decay = has_weight_decay
# Input
_shape = (batch_size, self.data.FRAMES, self.data.CROP_SIZE,
self.data.CROP_SIZE, self.data.CHANNELS)
self.images_placeholder = tf.placeholder(tf.float32, _shape)
self.labels_placeholder = tf.placeholder(tf.int64,
shape=(self.batch_size, ))
# Net
self.logits = net(self.images_placeholder, 0.5, self.data.NUM_CLASSES)
# Output
self.pred = tf.argmax(self.logits, 1)
self.loss = self.cal_loss(self.labels_placeholder, self.logits,
self.has_weight_decay)
self.accuracy = self.cal_acc(self.pred, self.labels_placeholder)
# learning rate
self.now_epoch = tf.Variable(0, trainable=False, name="epoch")
self.add_epoch_op = tf.assign_add(self.now_epoch, 1)
self.learning_rate = tf.train.piecewise_constant(
self.now_epoch, [10, 20], [0.0001, 0.00005, 0.00001])
self.train_op = tf.train.AdamOptimizer(self.learning_rate).minimize(
self.loss)
self.summary_op = tf.summary.merge_all()
# Sess
self.sess = tf.Session(config=tf.ConfigProto(gpu_options=tf.GPUOptions(
allow_growth=True)))
self.sess.run(tf.global_variables_initializer())
self.saver = tf.train.Saver(var_list=tf.global_variables(),
max_to_keep=5)
self.summary_writer = tf.summary.FileWriter(self.log_dir,
self.sess.graph)
pass
class Config(object):
multi_gpu = True
gpu_id = "0,1,2,3" if multi_gpu else "0"
# gpu_id = "1,2,3" if multi_gpu else "0"
gpu_num = len(gpu_id.split(","))
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
num_workers = 32
num_way = 5
num_shot = 1
val_freq = 10
episode_size = 15
test_episode = 600
# ic
ic_out_dim = 512
ic_ratio = 1
learning_rate = 0.01
train_epoch = 1500
first_epoch, t_epoch = 500, 200
adjust_learning_rate = RunnerTool.adjust_learning_rate1
###############################################################################################
# ic_net, net_name = EncoderC4(), "ICConv4"
ic_net, net_name = EncoderResNet12(), "ICResNet12"
# ic_net, net_name = EncoderResNet34(), "ICResNet34"
# matching_net, batch_size, net_name = EncoderC4(), 64, net_name + "MNConv4"
matching_net, batch_size, net_name = EncoderResNet12(
), 16, net_name + "MNResNet12"
# matching_net, batch_size, net_name = EncoderResNet34(), 16, net_name + "MNRResNet34"
###############################################################################################
batch_size = batch_size * gpu_num
model_name = "{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_png".format(
gpu_id.replace(",", ""), net_name, train_epoch, batch_size, num_way,
num_shot, first_epoch, t_epoch, ic_out_dim, ic_ratio)
Tools.print(model_name)
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
data_root = os.path.join(data_root, "miniImageNet_png")
Tools.print(data_root)
_root_path = "../models_abl/mn/two_ic_ufsl_1net_2net_duli"
mn_dir = Tools.new_dir("{}/{}_mn.pkl".format(_root_path, model_name))
ic_dir = Tools.new_dir("{}/{}_ic.pkl".format(_root_path, model_name))
pass
class Config(object):
multi_gpu = False
gpu_id = "1,2,3" if multi_gpu else "0"
# gpu_id = "1,2,3" if multi_gpu else "1"
gpu_num = len(gpu_id.split(","))
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
num_workers = 16
num_way = 10
num_way_test = 5
num_shot = 1
val_freq = 5
episode_size = 15
test_episode = 600
# ic
ic_out_dim = 2048
ic_ratio = 1
learning_rate = 0.01
train_epoch = 1600
first_epoch, t_epoch = 1000, 300
adjust_learning_rate = RunnerTool.adjust_learning_rate1
###############################################################################################
ic_net, net_name = EncoderC4(), "ICConv4"
matching_net, batch_size, net_name = EncoderC4(), 64, net_name + "MNConv4"
###############################################################################################
batch_size = batch_size * gpu_num
model_name = "{}_{}_{}_{}_{}_{}_{}_{}_{}_{}".format(
gpu_id.replace(",", ""), net_name, train_epoch, batch_size,
num_way, num_shot, first_epoch, t_epoch, ic_out_dim, ic_ratio)
Tools.print(model_name)
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/mn/two_ic_ufsl_1net_2net_duli"
mn_dir = Tools.new_dir("{}/{}_mn.pkl".format(_root_path, model_name))
ic_dir = Tools.new_dir("{}/{}_ic.pkl".format(_root_path, model_name))
pass
class Config(object):
gpu_id = 0
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
num_workers = 16
num_way = 5
num_shot = 1
batch_size = 64
val_freq = 10
episode_size = 15
test_episode = 600
feature_encoder, relation_network = CNNEncoder(), RelationNetwork()
# ic
ic_out_dim = 512
# ic_out_dim = 2560
ic_ratio = 1
learning_rate = 0.01
# loss_fsl_ratio = 10.0
# loss_ic_ratio = 0.1
loss_fsl_ratio = 1.0
loss_ic_ratio = 1.0
# train_epoch = 500
# first_epoch, t_epoch = 300, 150
# adjust_learning_rate = RunnerTool.adjust_learning_rate2
train_epoch = 2100
first_epoch, t_epoch = 500, 200
adjust_learning_rate = RunnerTool.adjust_learning_rate1
model_name = "{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}".format(
gpu_id, train_epoch, batch_size, num_way, num_shot, first_epoch,
t_epoch, ic_out_dim, ic_ratio, loss_fsl_ratio, loss_ic_ratio)
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
_root_path = "../models/two_ic_ufsl_2net_res_sgd_acc"
fe_dir = Tools.new_dir("{}/{}_fe_{}way_{}shot.pkl".format(
_root_path, model_name, num_way, num_shot))
rn_dir = Tools.new_dir("{}/{}_rn_{}way_{}shot.pkl".format(
_root_path, model_name, num_way, num_shot))
ic_dir = Tools.new_dir("{}/{}_ic_{}way_{}shot.pkl".format(
_root_path, model_name, num_way, num_shot))
pass
def train(config):
voc_runner = VOCRunner(config=config)
if config.only_inference_ss:
dataset_ss_inference_train, dataset_ss_inference_val, dataset_ss_inference_test = DatasetUtil.get_dataset_by_type(
DatasetUtil.dataset_type_ss_voc_val_scale,
config.ss_size,
scales=config.scales,
data_root=config.data_root_path)
data_loader_ss_inference_train = DataLoader(dataset_ss_inference_train,
1,
False,
num_workers=8)
data_loader_ss_inference_val = DataLoader(dataset_ss_inference_val,
1,
False,
num_workers=8)
data_loader_ss_inference_test = DataLoader(dataset_ss_inference_test,
1,
False,
num_workers=8)
voc_runner.inference_ss(model_file_name=config.model_file_name,
data_loader=data_loader_ss_inference_train,
save_path=Tools.new_dir(
os.path.join(config.eval_save_path,
"train")))
voc_runner.inference_ss(model_file_name=config.model_file_name,
data_loader=data_loader_ss_inference_val,
save_path=Tools.new_dir(
os.path.join(config.eval_save_path,
"val")))
voc_runner.inference_ss(model_file_name=config.model_file_name,
data_loader=data_loader_ss_inference_test,
save_path=Tools.new_dir(
os.path.join(config.eval_save_path,
"test")))
return
if config.only_eval_ss:
voc_runner.eval_ss(
epoch=0,
model_file_name=
"../../../WSS_Model_VOC/5_DeepLabV3PlusResNet101_21_100_18_5_513/ss_90.pth"
)
return
if config.only_train_ss:
voc_runner.train_ss(start_epoch=0, model_file_name=None)
return
pass
class Config(object):
gpu_id = 0
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
num_workers = 8
num_way = 5
num_shot = 1
val_freq = 10
episode_size = 15
test_episode = 600
learning_rate = 0.01
loss_fsl_ratio = 1.0
loss_ic_ratio = 1.0
train_epoch = 2100
first_epoch, t_epoch = 500, 200
adjust_learning_rate = RunnerTool.adjust_learning_rate1
ic_out_dim = 512
ic_ratio = 1
##############################################################################################################
is_png = True
# is_png = False
# has_l2norm = True
has_l2norm = False
resnet, resnet_name = resnet18, "resnet18"
# resnet, resnet_name = resnet34, "resnet34"
# proto_net, proto_name, batch_size = ProtoNet(hid_dim=64, z_dim=64, has_norm=has_norm), "ProtoNet", 64
proto_net, proto_name, batch_size = ProtoNetLarge(has_norm=has_l2norm), "ProtoNetLarge", 32
##############################################################################################################
model_name = "{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}{}{}".format(
gpu_id, train_epoch, first_epoch, t_epoch, batch_size, num_way, num_shot,
ic_out_dim, ic_ratio, loss_fsl_ratio, loss_ic_ratio, resnet_name, proto_name,
"_l2norm" if has_l2norm else "", "_png" if is_png else "")
Tools.print(model_name)
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
data_root = os.path.join(data_root, "miniImageNet_png") if is_png else data_root
Tools.print(data_root)
_root_path = "../models_pn/ufsl_abl"
pn_dir = Tools.new_dir("{}/{}_pn_{}_{}.pkl".format(_root_path, model_name, num_way, num_shot))
ic_dir = Tools.new_dir("{}/{}_ic_{}_{}.pkl".format(_root_path, model_name, num_way, num_shot))
pass
class Config(object):
os.environ["CUDA_VISIBLE_DEVICES"] = "2"
learning_rate = 0.01
num_workers = 8
num_way = 5
num_shot = 1
batch_size = 64
val_freq = 10
episode_size = 15
test_episode = 600
# ic
ic_in_dim = 64
ic_out_dim = 512
ic_ratio = 1
loss_fsl_ratio = 10.0
loss_ic_ratio = 0.1
train_epoch = 600
first_epoch, t_epoch = 300, 150
adjust_learning_rate = RunnerTool.adjust_learning_rate2
feature_encoder, relation_network = CNNEncoder(), RelationNetwork()
# feature_encoder, relation_network = CNNEncoder1(), RelationNetwork1()
model_name = "2_{}_{}_{}_{}_{}_{}_{}_{}_{}".format(
train_epoch, batch_size, first_epoch, t_epoch, ic_in_dim, ic_out_dim,
ic_ratio, loss_fsl_ratio, loss_ic_ratio)
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
fe_dir = Tools.new_dir(
"../models/two_ic_fsl_sgd/{}_fe_{}way_{}shot.pkl".format(
model_name, num_way, num_shot))
rn_dir = Tools.new_dir(
"../models/two_ic_fsl_sgd/{}_rn_{}way_{}shot.pkl".format(
model_name, num_way, num_shot))
ic_dir = Tools.new_dir(
"../models/two_ic_fsl_sgd/{}_ic_{}way_{}shot.pkl".format(
model_name, num_way, num_shot))
pass
class Config(object):
os.environ["CUDA_VISIBLE_DEVICES"] = "2"
num_workers = 8
batch_size = 64
val_freq = 2
learning_rate = 0.001
learning_rate_small = 0.001
num_way = 5
num_shot = 1
episode_size = 15
test_episode = 600
feature_encoder, relation_network = CNNEncoder(), RelationNetwork()
fe_pretrain = "../models/ic/1_64_512_1_500_200_0.01_fe.pkl"
ic_pretrain = "../models/ic/1_64_512_1_500_200_0.01_ic.pkl"
# ic
ic_in_dim = 64
ic_out_dim = 512
ic_ratio = 2
train_epoch = 300
loss_fsl_ratio = 10.0
loss_ic_ratio = 0.1
model_name = "4_{}_{}_{}_{}_{}_{}_{}_{}_{}".format(
train_epoch, batch_size, num_way, num_shot, ic_in_dim, ic_out_dim,
ic_ratio, loss_fsl_ratio, loss_ic_ratio)
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
root_path = "../models/two_ic_ufsl_pretrain"
fe_dir = Tools.new_dir("{}/{}_fe_{}way_{}shot.pkl".format(
root_path, model_name, num_way, num_shot))
rn_dir = Tools.new_dir("{}/{}_rn_{}way_{}shot.pkl".format(
root_path, model_name, num_way, num_shot))
ic_dir = Tools.new_dir("{}/{}_ic_{}way_{}shot.pkl".format(
root_path, model_name, num_way, num_shot))
pass
def process_folder(all_png, out_dir):
label_dict = utils.get_label_dict()
folders = utils.get_ordered_folders()
val_ground_dict = utils.get_val_ground_dict()
labels_searched = []
for folder in folders:
labels_searched.append(label_dict[folder])
labels_list = []
images = []
for image_index, image_name in enumerate(all_png):
if image_index % 1000 == 0:
Tools.print("{} {}".format(image_index, len(all_png)))
basename = os.path.basename(image_name)
label = val_ground_dict[basename[:-4]]
if label not in labels_searched:
continue
try:
img = imageio.imread(image_name)
r = img[:, :, 0].flatten()
g = img[:, :, 1].flatten()
b = img[:, :, 2].flatten()
except:
Tools.print('Cant process image {}'.format(basename))
with open("log_img2np_val.txt", "a") as f:
f.write("Couldn't read: {}".format(image_name))
continue
arr = np.array(list(r) + list(g) + list(b), dtype=np.uint8)
images.append(arr)
labels_list.append(label)
pass
data_val = np.row_stack(images)
# Can add some kind of data splitting
d_val = {'data': data_val, 'labels': labels_list}
Tools.new_dir(out_dir)
pickle.dump(d_val, open(os.path.join(out_dir, 'val_data'), 'wb'))
y_test = d_val['labels']
count = np.zeros([1000])
for i in y_test:
count[i - 1] += 1
for i in range(1000):
Tools.print('%d : %d' % (i, count[i]))
Tools.print('SUM: %d' % len(y_test))
pass
class Config(object):
os.environ["CUDA_VISIBLE_DEVICES"] = "1"
num_workers = 8
batch_size = 64
val_freq = 10
learning_rate = 0.001
num_way = 5
num_shot = 1
episode_size = 15
test_episode = 600
# ic
ic_in_dim = 256
ic_out_dim = 512
ic_ratio = 1
feature_encoder, relation_network = VGGEncoder(), VGGRelationNetwork()
ic_model = VGGICModel(in_dim=ic_in_dim, out_dim=ic_out_dim)
train_epoch = 600
loss_fsl_ratio = 20.0
loss_ic_ratio = 0.1
model_name = "1_{}_{}_{}_{}_{}_{}_{}_{}_{}".format(
train_epoch, batch_size, num_way, num_shot, ic_in_dim, ic_out_dim,
ic_ratio, loss_fsl_ratio, loss_ic_ratio)
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
fe_dir = Tools.new_dir(
"../models/two_ic_fsl_large/{}_fe_{}way_{}shot.pkl".format(
model_name, num_way, num_shot))
rn_dir = Tools.new_dir(
"../models/two_ic_fsl_large/{}_rn_{}way_{}shot.pkl".format(
model_name, num_way, num_shot))
ic_dir = Tools.new_dir(
"../models/two_ic_fsl_large/{}_ic_{}way_{}shot.pkl".format(
model_name, num_way, num_shot))
pass
class Config(object):
gpu_id = 3
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
num_workers = 24
batch_size = 64
val_freq = 10
learning_rate = 0.001
num_way = 5
num_shot = 1
episode_size = 15
test_episode = 600
feature_encoder, relation_network = CNNEncoder(), RelationNetwork()
# ic
ic_in_dim = 64
ic_out_dim = 512
ic_ratio = 1
train_epoch = 900
loss_fsl_ratio = 10.0
loss_ic_ratio = 0.1
model_name = "{}_{}_{}_{}_{}_{}_{}_{}_{}_{}".format(
gpu_id, train_epoch, batch_size, num_way, num_shot, ic_in_dim,
ic_out_dim, ic_ratio, loss_fsl_ratio, loss_ic_ratio)
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
fe_dir = Tools.new_dir(
"../models/two_ic_ufsl_acc/{}_fe_{}way_{}shot.pkl".format(
model_name, num_way, num_shot))
rn_dir = Tools.new_dir(
"../models/two_ic_ufsl_acc/{}_rn_{}way_{}shot.pkl".format(
model_name, num_way, num_shot))
ic_dir = Tools.new_dir(
"../models/two_ic_ufsl_acc/{}_ic_{}way_{}shot.pkl".format(
model_name, num_way, num_shot))
pass
class Config(object):
gpu_id = 1
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
num_workers = 8
batch_size = 8
# resnet, vggnet, net_name = resnet18, None, "resnet_18"
resnet, vggnet, net_name = resnet34, None, "resnet_34"
# resnet, vggnet, net_name = resnet50, None, "resnet_50"
# resnet, vggnet, net_name = None, vgg16_bn, "vgg16_bn"
# modify_head = False
modify_head = True
is_png = True
# is_png = False
# ic
ic_out_dim = 512
ic_dir = "../models/ic_res_xx/3_resnet_34_64_512_1_2100_500_2000.01_ic.pkl"
vis_dir = Tools.new_dir("../vis/miniImagenet/ic_res_xx/3_resnet_34_64_512_1_2100_500_200")
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
data_root = os.path.join(data_root, "miniImageNet_png") if is_png else data_root
Tools.print(data_root)
pass
def vis(self, split="train"):
Tools.print()
Tools.print("Vis ...")
loader = self.test_loader if split == "test" else self.train_loader
loader = self.val_loader if split == "val" else loader
feature_list = []
self.ic_model.eval()
for image_transform, image, label, idx in tqdm(loader):
ic_out_logits, ic_out_l2norm = self.ic_model(self.to_cuda(image_transform))
image_data = np.asarray(image.permute(0, 2, 3, 1) * 255, np.uint8)
cluster_id = np.asarray(torch.argmax(ic_out_logits, -1).cpu())
for i in range(len(idx)):
feature_list.append([int(idx[i]), int(label[i]), int(cluster_id[i]),
np.array(ic_out_logits[i].cpu().detach().numpy()),
np.array(ic_out_l2norm[i].cpu().detach().numpy())])
result_path = Tools.new_dir(os.path.join(Config.vis_dir, split, str(cluster_id[i])))
Image.fromarray(image_data[i]).save(os.path.join(result_path, "{}_{}.png".format(label[i], idx[i])))
pass
pass
Tools.write_to_pkl(os.path.join(Config.vis_dir, "{}.pkl".format(split)), feature_list)
pass
class Config(object):
os.environ["CUDA_VISIBLE_DEVICES"] = "2"
start_epoch = 0
max_epoch = 1600
learning_rate = 0.01
first_epoch, t_epoch = 200, 100
low_dim = 512
ratio = 1
# ratio = 2
has_entropy = False
# has_entropy = True
batch_size = 64
resume = False
pre_train = None
name = "{}_{}_{}_{}_{}_{}_{}".format(max_epoch, batch_size, low_dim, ratio, first_epoch, t_epoch, has_entropy)
checkpoint_path = Tools.new_dir("../models_ic/{}/ckpt.t7".format(name))
if "Linux" in platform.platform():
data_root = "/mnt/4T/Data/data/CIFAR"
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/cifar'
else:
data_root ="F:\\data\\cifar10"
pass
def __init__(self, data_root_path='/mnt/4T/Data/cifar/cifar-10',
batch_size=64, image_size=224, sp_size=8, train_print_freq=100, test_print_freq=50,
root_ckpt_dir="./ckpt2/norm3", num_workers=8, use_gpu=True, gpu_id="1"):
self.train_print_freq = train_print_freq
self.test_print_freq = test_print_freq
self.device = gpu_setup(use_gpu=use_gpu, gpu_id=gpu_id)
self.root_ckpt_dir = Tools.new_dir(root_ckpt_dir)
self.train_dataset = MyDataset(data_root_path=data_root_path,
is_train=True, image_size=image_size, sp_size=sp_size)
self.test_dataset = MyDataset(data_root_path=data_root_path,
is_train=False, image_size=image_size, sp_size=sp_size)
self.train_loader = DataLoader(self.train_dataset, batch_size=batch_size, shuffle=True,
num_workers=num_workers, collate_fn=self.train_dataset.collate_fn)
self.test_loader = DataLoader(self.test_dataset, batch_size=batch_size, shuffle=False,
num_workers=num_workers, collate_fn=self.test_dataset.collate_fn)
self.model = MyGCNNet().to(self.device)
# self.lr_s = [[0, 0.001], [25, 0.001], [50, 0.0002], [75, 0.00004]]
self.lr_s = [[0, 0.01], [10, 0.001], [20, 0.0001], [30, 0.00001]]
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr_s[0][0], weight_decay=0.0)
# self.optimizer = torch.optim.SGD(self.model.parameters(), lr=self.lr_s[0][0], momentum=0.9, weight_decay=5e-4)
self.loss_class = nn.CrossEntropyLoss().to(self.device)
Tools.print("Total param: {}".format(self._view_model_param(self.model)))
pass
def __init__(self, gcn_model=GCNNet, data_root_path='/mnt/4T/Data/cifar/cifar-10',
ve_model_file_name="./ckpt/norm3/epoch_7.pkl", cos_sim_th=0.5,
root_ckpt_dir="./ckpt2/norm3", num_workers=8, use_gpu=True, gpu_id="1"):
self.device = gpu_setup(use_gpu=use_gpu, gpu_id=gpu_id)
_image_size = 32
_sp_size = 4
_sp_ve_size = 6
_cos_sim_th = cos_sim_th
_VEModel = EmbeddingNetCIFARSmallNorm3
self.root_ckpt_dir = Tools.new_dir(root_ckpt_dir)
self.train_dataset = MyDataset(data_root_path=data_root_path, is_train=True, cos_sim_th=_cos_sim_th,
ve_model_file_name=ve_model_file_name, VEModel=_VEModel,
image_size=_image_size, sp_size=_sp_size, sp_ve_size=_sp_ve_size)
self.test_dataset = MyDataset(data_root_path=data_root_path, is_train=False, cos_sim_th=_cos_sim_th,
ve_model_file_name=ve_model_file_name, VEModel=_VEModel,
image_size=_image_size, sp_size=_sp_size, sp_ve_size=_sp_ve_size)
self.train_loader = DataLoader(self.train_dataset, batch_size=64, shuffle=True,
num_workers=num_workers, collate_fn=self.train_dataset.collate_fn)
self.test_loader = DataLoader(self.test_dataset, batch_size=64, shuffle=False,
num_workers=num_workers, collate_fn=self.test_dataset.collate_fn)
self.model = gcn_model().to(self.device)
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=0.005, weight_decay=0.0)
self.loss = nn.CrossEntropyLoss().to(self.device)
pass
def train_eval_ss(self, data_loader, epoch=0, model_file_name=None):
if model_file_name is not None:
Tools.print("Load model form {}".format(model_file_name), txt_path=self.config.ss_save_result_txt)
self.load_model(model_file_name)
pass
self.net.eval()
with torch.no_grad():
for i, (inputs, labels, image_paths) in tqdm(enumerate(data_loader), total=len(data_loader)):
inputs = inputs.float().cuda()
outputs = self.net(inputs)
preds = outputs.detach().max(dim=1)[1].cpu().numpy()
for j, (pred_one, label_one, image_path) in enumerate(zip(preds, labels, image_paths)):
im = Image.open(image_path)
now_name = image_path.split("Data/DET/")[1]
result_filename = Tools.new_dir(os.path.join(self.config.ss_train_eval_save_dir, now_name))
im.save(result_filename)
DataUtil.gray_to_color(np.asarray(pred_one, dtype=np.uint8)).resize(im.size).save(
result_filename.replace(".JPEG", "_new.png"))
DataUtil.gray_to_color(np.asarray(label_one, dtype=np.uint8)).resize(im.size).save(
result_filename.replace(".JPEG", "_old.png"))
pred_one[pred_one != label_one & label_one != 255] = 255
DataUtil.gray_to_color(np.asarray(pred_one, dtype=np.uint8)).resize(im.size).save(
result_filename.replace(".JPEG", ".png"))
pass
pass
pass
pass
def __init__(self):
self.gpu_id = "1, 2, 3"
# self.gpu_id = "0, 1, 2, 3"
os.environ["CUDA_VISIBLE_DEVICES"] = str(self.gpu_id)
# 流程控制
self.only_train = True # 是否训练
self.only_eval = False
self.only_train_debug = False
self.is_supervised = True
# Train
self.sampling = False
# Eval
self.model_pth = None
self.model_eval_dir = None
self.model_pth = "../../../WSS_Model_My/DSS/5_DualNet_20_50_32_5_224/final_50.pth"
self.model_eval_dir = "../../../WSS_Model_My/DEval/5_DualNet_20_50_32_5_224"
# Debug
self.model_resume_pth = "../../../WSS_Model_My/DSS/4_DualNet_20_100_32_5_224/50.pth"
self.has_class = True
self.has_cam = True
self.has_ss = True
# 伪标签
if self.is_supervised:
self.train_label_path = None
else:
self.train_label_path = "/mnt/4T/ALISURE/USS/ConTa/pseudo_mask_voc/result/2/sem_seg/train_aug"
self.num_classes = 20
self.lr = 0.001
self.epoch_num = 80
self.milestones = [40, 60]
self.save_epoch_freq = 5
self.eval_epoch_freq = 5
# self.input_size = 352
# self.input_size_val = 352
# self.batch_size = 4 * len(self.gpu_id.split(","))
self.input_size = 224
self.input_size_val = 224
self.batch_size = 8 * len(self.gpu_id.split(","))
# 网络
self.Net, self.met_name = DualNet, "DualNet"
self.data_root_path = self.get_data_root_path()
run_name = "6"
self.model_name = "{}_{}_{}_{}_{}_{}_{}_{}".format(
run_name, self.met_name, self.num_classes, self.epoch_num,
self.batch_size, self.save_epoch_freq, self.input_size, self.input_size_val)
Tools.print(self.model_name)
self.model_dir = "../../../WSS_Model_My/DSS/{}".format(self.model_name)
self.save_result_txt = Tools.new_dir("{}/result.txt".format(self.model_dir))
pass
class Config(object):
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
# train_epoch = 300
train_epoch = 180
learning_rate = 0.0005
num_workers = 8
val_freq = 10
num_way = 5
num_shot = 1
batch_size = 64
episode_size = 15
test_episode = 600
z_dim = 512
proto_net = ProtoResNet(low_dim=z_dim)
pn_pretrain = "../models/ic_res_no_val/1_32_512_1_500_200_0.01_ic.pkl"
model_name = "new_0_{}_{}_{}_{}".format(train_epoch, batch_size, z_dim, learning_rate)
if "Linux" in platform.platform():
data_root = '/mnt/4T/Data/data/miniImagenet'
if not os.path.isdir(data_root):
data_root = '/media/ubuntu/4T/ALISURE/Data/miniImagenet'
else:
data_root = "F:\\data\\miniImagenet"
root_path = "../models_pn/fsl_res_pretrain_sgd"
pn_dir = Tools.new_dir("{}/{}_pn_{}way_{}shot.pkl".format(root_path, model_name, num_way, num_shot))
pass
def __init__(self, data_root_path, batch_size=64, image_size=320, sp_size=4, pool_ratio=2, train_print_freq=100,
test_print_freq=50, root_ckpt_dir="./ckpt2", num_workers=8, use_gpu=True, gpu_id="1", is_sgd=False):
self.train_print_freq = train_print_freq
self.test_print_freq = test_print_freq
self.root_ckpt_dir = Tools.new_dir(root_ckpt_dir)
self.device = gpu_setup(use_gpu=use_gpu, gpu_id=gpu_id)
self.train_dataset = MyDataset(data_root_path=data_root_path, is_train=True,
image_size=image_size, sp_size=sp_size, pool_ratio=pool_ratio)
self.test_dataset = MyDataset(data_root_path=data_root_path, is_train=False,
image_size=image_size, sp_size=sp_size, pool_ratio=pool_ratio)
self.train_loader = DataLoader(self.train_dataset, batch_size=batch_size, shuffle=True,
num_workers=num_workers, collate_fn=self.train_dataset.collate_fn)
self.test_loader = DataLoader(self.test_dataset, batch_size=batch_size, shuffle=False,
num_workers=num_workers, collate_fn=self.test_dataset.collate_fn)
self.model = MyGCNNet().to(self.device)
if is_sgd:
self.lr_s = [[0, 0.01], [50, 0.001], [80, 0.0001]]
self.optimizer = torch.optim.SGD(self.model.parameters(),
lr=self.lr_s[0][0], momentum=0.9, weight_decay=5e-4)
else:
self.lr_s = [[0, 0.001], [50, 0.0003], [75, 0.0001]]
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr_s[0][0], weight_decay=0.0)
pass
self.loss_class = nn.BCELoss().to(self.device)
Tools.print("Total param: {}".format(self._view_model_param(self.model)))
pass
