def fit_target(src_model, tgt_model, tgt_opt, disc_model, disc_opt,
src_trainloader, tgt_trainloader, tgt_valloader, history,
exp_dict):
for e in range(history["tgt_train"][-1]["epoch"],
exp_dict["tgt_epochs"] + 1):
# 1. Train disc
if exp_dict["options"]["disc"] == True:
fit_discriminator(src_model,
tgt_model,
disc_model,
src_trainloader,
tgt_trainloader,
opt_tgt=tgt_opt,
opt_disc=disc_opt,
epochs=3,
verbose=0)
acc_tgt = test.validate(src_model, tgt_model, src_trainloader,
tgt_valloader)
history["tgt_train"] += [{
"epoch":
e,
"acc_src":
history["src_acc"],
"acc_tgt":
acc_tgt,
"n_train - " + exp_dict["src_dataset"]:
len(src_trainloader.dataset),
"n_train - " + exp_dict["tgt_dataset"]:
len(tgt_trainloader.dataset),
"n_test - " + exp_dict["tgt_dataset"]:
len(tgt_valloader.dataset)
}]
print("\n>>> Methods: {} - Source: {} -> Target: {}".format(
None, exp_dict["src_dataset"], exp_dict["tgt_dataset"]))
print(pd.DataFrame([history["tgt_train"][-1]]))
if (e % 5) == 0:
ms.save_model_tgt(exp_dict, history, tgt_model, tgt_opt,
disc_model, disc_opt)
#ms.test_latest_model(exp_dict)
# 2. Train center-magnet
if exp_dict["options"]["center"] == True:
fit_center(src_model,
tgt_model,
src_trainloader,
tgt_trainloader,
tgt_opt,
epochs=1)
return history
def train(exp_dict):
history = ms.load_history(exp_dict)
if 'only_supervised' in exp_dict:
tgt_trainloader_supervised, tgt_testloader_supervised = ms.get_tgt_loader_supervised(
exp_dict)
# load models
tgt_model, tgt_opt, tgt_scheduler, _, _, _ = ms.load_model_tgt(
exp_dict)
fit_source_supervised(tgt_model, tgt_opt, tgt_scheduler,
tgt_trainloader_supervised, exp_dict)
tgt_acc = test.validate(tgt_model, tgt_model,
tgt_trainloader_supervised,
tgt_testloader_supervised)
print("{} TEST Accuracy Supervised =========== {:2%}\n".format(
exp_dict["tgt_dataset"], tgt_acc))
ms.save_model_tgt(exp_dict, history, tgt_model, tgt_opt)
else:
# Source
src_trainloader, src_valloader = ms.load_src_loaders(exp_dict)
####################### 1. Train source model
src_model, src_opt, src_scheduler = ms.load_model_src(exp_dict)
# Train Source
if exp_dict["reset_src"]:
history = fit_source(src_model, src_opt, src_scheduler,
src_trainloader, history, exp_dict)
# Test Source
src_acc = test.validate(src_model, src_model, src_trainloader,
src_valloader)
print("{} TEST Accuracy = {:2%}\n".format(exp_dict["src_dataset"],
src_acc))
history["src_acc"] = src_acc
ms.save_model_src(exp_dict, history, src_model, src_opt)
####################### 2. Train target model
tgt_trainloader, tgt_valloader = ms.load_tgt_loaders(exp_dict)
#load models
tgt_model, tgt_opt, tgt_scheduler, disc_model, disc_opt, disc_scheduler = ms.load_model_tgt(
exp_dict)
tgt_model.load_state_dict(src_model.state_dict())
if exp_dict["reset_tgt"]:
history = fit_target(src_model, tgt_model, tgt_opt, tgt_scheduler,
disc_model, disc_opt, disc_scheduler,
src_trainloader, tgt_trainloader,
tgt_valloader, history, exp_dict)
def train(exp_dict):
history = ms.load_history(exp_dict)
# Source
src_trainloader, src_valloader = ms.load_src_loaders(exp_dict)
####################### 1. Train source model
src_model, src_opt = ms.load_model_src(exp_dict)
# Train Source
history = fit_source(src_model, src_opt, src_trainloader, history,
exp_dict)
# Test Source
src_acc = test.validate(src_model, src_model, src_trainloader,
src_valloader)
print("{} TEST Accuracy = {:2%}\n".format(exp_dict["src_dataset"],
src_acc))
history["src_acc"] = src_acc
ms.save_model_src(exp_dict, history, src_model, src_opt)
####################### 2. Train target model
tgt_trainloader, tgt_valloader = ms.load_tgt_loaders(exp_dict)
# load models
tgt_model, tgt_opt, disc_model, disc_opt = ms.load_model_tgt(exp_dict)
tgt_model.load_state_dict(src_model.state_dict())
history = fit_target(src_model, tgt_model, tgt_opt, disc_model, disc_opt,
src_trainloader, tgt_trainloader, tgt_valloader,
history, exp_dict)
ms.save_model_tgt(exp_dict, history, tgt_model, tgt_opt, disc_model,
disc_opt)
exp_dict["reset_src"] = 0
exp_dict["reset_tgt"] = 0
ms.test_latest_model(exp_dict)
def fit_target(src_model, tgt_model, tgt_opt, tgt_scheduler, disc_model,
disc_opt, disc_scheduler, src_trainloader, tgt_trainloader,
tgt_valloader, history, exp_dict):
acc_tgt_old = test.validate(src_model, tgt_model, src_trainloader,
tgt_valloader)
history["tgt_train"] += [{
"epoch":
0,
"acc_src":
history["src_acc"],
"acc_tgt":
acc_tgt_old,
"n_train - " + exp_dict["src_dataset"]:
len(src_trainloader.dataset),
"n_train - " + exp_dict["tgt_dataset"]:
len(tgt_trainloader.dataset),
"n_test - " + exp_dict["tgt_dataset"]:
len(tgt_valloader.dataset)
}]
print("\n>>> Methods: {} - Source: {} -> Target: {} ---------- Originally".
format(None, exp_dict["src_dataset"], exp_dict["tgt_dataset"]))
print(pd.DataFrame([history["tgt_train"][-1]]))
ms.save_model_tgt(exp_dict, history, tgt_model, tgt_opt, disc_model,
disc_opt)
if 'tgt_supervised' in exp_dict:
tgt_trainloader_supervised, tgt_testloader_supervised = ms.get_tgt_loader_supervised(
exp_dict)
tgt_acc_old = 0
####
tgt_scheduler = torch.optim.lr_scheduler.MultiStepLR(
tgt_opt, milestones=[exp_dict['tgt_epochs'] // 2], gamma=0.1)
disc_scheduler = torch.optim.lr_scheduler.MultiStepLR(
disc_opt, milestones=[exp_dict['tgt_epochs'] // 2], gamma=0.1)
####
for e in range(history["tgt_train"][-1]["epoch"] + 1,
exp_dict["tgt_epochs"] + 1):
# train supervised by target
# 1. Train disc
if exp_dict["options"]["disc"] == True:
fit_discriminator(src_model,
tgt_model,
disc_model,
src_trainloader,
tgt_trainloader,
opt_tgt=tgt_opt,
opt_disc=disc_opt,
epochs=exp_dict['tgt_disc_epochs'],
verbose=0)
print("\n>>> Source: {} -> Target: {} - Epochs: [{}/{}]".format(
exp_dict["src_dataset"], exp_dict["tgt_dataset"], e,
exp_dict["tgt_epochs"]))
#### 1.2. fit supervised training
if 'tgt_supervised' in exp_dict:
fit_source_supervised(tgt_model, tgt_opt, tgt_scheduler,
tgt_trainloader_supervised, exp_dict)
# save and test model
test_epoch = 1 #exp_dict["tgt_epochs"] ##// 5
if e % test_epoch == 0:
if 'tgt_supervised' not in exp_dict:
acc_tgt = test.validate(src_model, tgt_model, src_trainloader,
tgt_valloader)
history["tgt_train"] += [{
"epoch":
e,
"acc_src":
history["src_acc"],
"acc_tgt":
acc_tgt,
"n_train - " + exp_dict["src_dataset"]:
len(src_trainloader.dataset),
"n_train - " + exp_dict["tgt_dataset"]:
len(tgt_trainloader.dataset),
"n_test - " + exp_dict["tgt_dataset"]:
len(tgt_valloader.dataset)
}]
print("\n>>> Methods: {} - Source: {} -> Target: {}".format(
None, exp_dict["src_dataset"], exp_dict["tgt_dataset"]))
print(pd.DataFrame([history["tgt_train"][-1]]))
ms.save_model_tgt(exp_dict, history, tgt_model, tgt_opt,
disc_model, disc_opt)
# if acc_tgt >= acc_tgt_old:
# ms.save_model_tgt(exp_dict, history, tgt_model, tgt_opt,
# disc_model, disc_opt)
# acc_tgt_old = acc_tgt
else:
tgt_acc = test.validate(tgt_model, tgt_model,
tgt_trainloader_supervised,
tgt_testloader_supervised)
print("{} TEST Accuracy Supervised =========== {:2%}\n".format(
exp_dict["tgt_dataset"], tgt_acc))
ms.save_model_tgt(exp_dict, history, tgt_model, tgt_opt,
disc_model, disc_opt)
# if tgt_acc >= tgt_acc_old:
# ms.save_model_tgt(exp_dict, history, tgt_model, tgt_opt, disc_model, disc_opt)
# tgt_acc_old = tgt_acc
# 2. Train center-magnet
if exp_dict["options"]["center"] == True:
fit_center(src_model,
tgt_model,
src_trainloader,
tgt_trainloader,
tgt_opt,
epochs=exp_dict['tgt_embedding_epochs'])
disc_scheduler.step()
tgt_scheduler.step()
return history
def train(exp_dict):
history = ms.load_history(exp_dict)
#Simone:
data_transform = transforms.Compose([
transforms.Resize((exp_dict['image_size'], exp_dict['image_size']),
interpolation=1),
transforms.ToTensor()
])
# CUDA for PyTorch
use_cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if use_cuda else "cpu")
history = ms.load_history(exp_dict)
src_trainloader = get_coxs2v_trainset(
exp_dict["still_dir"],
exp_dict["video1_dir"],
exp_dict["video1_pairs"],
train_folds,
exp_dict["cross_validation_num_fold"],
data_transform,
people_per_batch,
images_per_person,
video_only=True,
samples_division_list=[0.6, 0.4], # [0.6, 0.4]
div_idx=0)
src_valloader = get_coxs2v_trainset(
exp_dict["still_dir"],
exp_dict["video1_dir"],
exp_dict["video1_pairs"],
train_folds,
exp_dict["cross_validation_num_fold"],
data_transform,
people_per_batch,
images_per_person,
video_only=True,
samples_division_list=[0.6, 0.4], # [0.6, 0.4]
div_idx=1)
# Source
#src_trainloader, src_valloader = ms.load_src_loaders(exp_dict)
####################### 1. Train source model
src_model, src_opt = ms.load_model_src(exp_dict)
# Train Source
history = fit_source(src_model, src_opt, src_trainloader, history,
exp_dict)
# Test Source
src_acc = test.validate(src_model, src_model, src_trainloader,
src_valloader)
print("{} TEST Accuracy = {:2%}\n".format(exp_dict["src_dataset"],
src_acc))
history["src_acc"] = src_acc
ms.save_model_src(exp_dict, history, src_model, src_opt)
####################### 2. Train target model
#tgt_trainloader, tgt_valloader = ms.load_tgt_loaders(exp_dict)
tgt_trainloader = get_coxs2v_trainset(
exp_dict["still_dir"],
exp_dict["video2_dir"],
exp_dict["video2_pairs"],
train_folds,
exp_dict["cross_validation_num_fold"],
data_transform,
people_per_batch,
images_per_person,
video_only=True,
samples_division_list=[0.6, 0.4], # [0.6, 0.4]
div_idx=0)
tgt_valloader = get_coxs2v_trainset(
exp_dict["still_dir"],
exp_dict["video2_dir"],
exp_dict["video2_pairs"],
train_folds,
exp_dict["cross_validation_num_fold"],
data_transform,
people_per_batch,
images_per_person,
video_only=True,
samples_division_list=[0.6, 0.4], # [0.6, 0.4]
div_idx=1)
# load models
tgt_model, tgt_opt, disc_model, disc_opt = ms.load_model_tgt(exp_dict)
tgt_model.load_state_dict(src_model.state_dict())
history = fit_target(src_model, tgt_model, tgt_opt, disc_model, disc_opt,
src_trainloader, tgt_trainloader, tgt_valloader,
history, exp_dict)
ms.save_model_tgt(exp_dict, history, tgt_model, tgt_opt, disc_model,
disc_opt)
exp_dict["reset_src"] = 0
exp_dict["reset_tgt"] = 0
ms.test_latest_model(exp_dict)
def train(exp_dict):
history = ms.load_history(exp_dict)
# Source
src_trainloader, src_valloader = ms.load_src_loaders(exp_dict)
#####################
## Train source model
#####################
src_model, src_opt = ms.load_model_src(exp_dict)
# Train Source
for e in range(history["src_train"][-1]["epoch"], exp_dict["src_epochs"]):
train_dict = ts.fit_src(src_model, src_trainloader, src_opt)
loss = train_dict["loss"]
print("Source ({}) - Epoch [{}/{}] - loss={:.2f}".format(
type(src_trainloader).__name__, e, exp_dict["src_epochs"], loss))
history["src_train"] += [{"loss": loss, "epoch": e}]
if e % 50 == 0:
ms.save_model_src(exp_dict, history, src_model, src_opt)
# Test Source
src_acc = test.validate(src_model, src_model, src_trainloader,
src_valloader)
print("{} TEST Accuracy = {:2%}\n".format(exp_dict["src_dataset"],
src_acc))
history["src_acc"] = src_acc
ms.save_model_src(exp_dict, history, src_model, src_opt)
#####################
## Train Target model
#####################
tgt_trainloader, tgt_valloader = ms.load_tgt_loaders(exp_dict)
# load models
tgt_model, tgt_opt, disc_model, disc_opt = ms.load_model_tgt(exp_dict)
tgt_model.load_state_dict(src_model.state_dict())
for e in range(history["tgt_train"][-1]["epoch"],
exp_dict["tgt_epochs"] + 1):
# 1. Train disc
if exp_dict["options"]["disc"] == True:
tg.fit_disc(src_model,
tgt_model,
disc_model,
src_trainloader,
tgt_trainloader,
opt_tgt=tgt_opt,
opt_disc=disc_opt,
epochs=3,
verbose=0)
acc_tgt = test.validate(src_model, tgt_model, src_trainloader,
tgt_valloader)
history["tgt_train"] += [{
"epoch":
e,
"acc_src":
src_acc,
"acc_tgt":
acc_tgt,
"n_train - " + exp_dict["src_dataset"]:
len(src_trainloader.dataset),
"n_train - " + exp_dict["tgt_dataset"]:
len(tgt_trainloader.dataset),
"n_test - " + exp_dict["tgt_dataset"]:
len(tgt_valloader.dataset)
}]
print("\n>>> Methods: {} - Source: {} -> Target: {}".format(
None, exp_dict["src_dataset"], exp_dict["tgt_dataset"]))
print(pd.DataFrame([history["tgt_train"][-1]]))
if (e % 5) == 0:
ms.save_model_tgt(exp_dict, history, tgt_model, tgt_opt,
disc_model, disc_opt)
#ms.test_latest_model(exp_dict)
# 2. Train center-magnet
if exp_dict["options"]["center"] == True:
tg.fit_center(src_model,
tgt_model,
src_trainloader,
tgt_trainloader,
tgt_opt,
epochs=1)
ms.save_model_tgt(exp_dict, history, tgt_model, tgt_opt, disc_model,
disc_opt)
exp_dict["reset_src"] = 0
exp_dict["reset_tgt"] = 0
ms.test_latest_model(exp_dict)