def main():
# init random seed
init_random_seed(params.manual_seed)
# Load dataset
svhn_data_loader = get_svhn(split='train', download=True)
svhn_data_loader_eval = get_svhn(split='test', download=True)
mnist_data_loader = get_mnist(train=True, download=True)
mnist_data_loader_eval = get_mnist(train=False, download=True)
# Model init WDGRL
tgt_encoder = model_init(Encoder(), params.encoder_wdgrl_path)
critic = model_init(Discriminator(in_dims=params.d_in_dims,
h_dims=params.d_h_dims,
out_dims=params.d_out_dims),
params.disc_wdgrl_path)
clf = model_init(Classifier(), params.clf_wdgrl_path)
# Train critic to optimality
print("====== Training critic ======")
if not (critic.pretrained and params.model_trained):
critic = train_critic_wdgrl(tgt_encoder, critic, svhn_data_loader, mnist_data_loader)
# Train target encoder
print("====== Training encoder for both SVHN and MNIST domains ======")
if not (tgt_encoder.pretrained and clf.pretrained and params.model_trained):
tgt_encoder, clf = train_tgt_wdgrl(tgt_encoder, clf, critic,
svhn_data_loader, mnist_data_loader, robust=False)
# Eval target encoder on test set of target dataset
print("====== Evaluating classifier for encoded SVHN and MNIST domains ======")
print("-------- SVHN domain --------")
eval_tgt(tgt_encoder, clf, svhn_data_loader_eval)
print("-------- MNIST adaption --------")
eval_tgt(tgt_encoder, clf, mnist_data_loader_eval)
def main():
# init random seed
init_random_seed(params.manual_seed)
# Load dataset
mnist_data_loader = get_mnist(train=True, download=True)
mnist_data_loader_eval = get_mnist(train=False, download=True)
usps_data_loader = get_usps(train=True, download=True)
usps_data_loader_eval = get_usps(train=False, download=True)
# Model init Revgard
tgt_encoder = model_init(Encoder(), params.tgt_encoder_revgrad_path)
critic = model_init(Discriminator(), params.disc_revgard_path)
clf = model_init(Classifier(), params.clf_revgrad_path)
# Train models
print("====== Training source encoder and classifier in MNIST and USPS domains ======")
if not (tgt_encoder.pretrained and clf.pretrained and critic.pretrained and params.model_trained):
tgt_encoder, clf, critic = train_revgrad(tgt_encoder, clf, critic,
mnist_data_loader, usps_data_loader, robust=False)
# Eval target encoder on test set of target dataset
print("====== Evaluating classifier for encoded MNIST and USPS domain ======")
print("-------- MNIST domain --------")
eval_tgt(tgt_encoder, clf, mnist_data_loader_eval)
print("-------- USPS adaption --------")
eval_tgt(tgt_encoder, clf, usps_data_loader_eval)
def main():
# init random seed
init_random_seed(params.manual_seed)
# Load dataset
mnist_data_loader = get_mnist(train=True, download=True)
mnist_data_loader_eval = get_mnist(train=False, download=True)
usps_data_loader = get_usps(train=True, download=True)
usps_data_loader_eval = get_usps(train=False, download=True)
# Model init WDGRL
tgt_encoder = model_init(Encoder(), params.encoder_wdgrl_rb_path)
critic = model_init(Discriminator(), params.disc_wdgrl_rb_path)
clf = model_init(Classifier(), params.clf_wdgrl_rb_path)
# Train target encoder
print("====== Robust Training encoder for both MNIST and USPS domains ======")
if not (tgt_encoder.pretrained and clf.pretrained and params.model_trained):
tgt_encoder, clf = train_tgt_wdgrl(tgt_encoder, clf, critic,
mnist_data_loader, usps_data_loader, usps_data_loader_eval, robust=True)
# Eval target encoder on test set of target dataset
print("====== Evaluating classifier for encoded MNIST and USPS domains ======")
print("-------- MNIST domain --------")
eval_tgt_robust(tgt_encoder, clf, mnist_data_loader_eval)
print("-------- USPS adaption --------")
eval_tgt_robust(tgt_encoder, clf, usps_data_loader_eval)
def main():
# init random seed
init_random_seed(params.manual_seed)
# Load dataset
svhn_data_loader = get_svhn(split='train', download=True)
svhn_data_loader_eval = get_svhn(split='test', download=True)
mnist_data_loader = get_mnist(train=True, download=True)
mnist_data_loader_eval = get_mnist(train=False, download=True)
# Model init ADDA
src_encoder = model_init(Encoder(), params.src_encoder_adda_rb_path)
tgt_encoder = model_init(Encoder(), params.tgt_encoder_adda_rb_path)
critic = model_init(
Discriminator(in_dims=params.d_in_dims,
h_dims=params.d_h_dims,
out_dims=params.d_out_dims), params.disc_adda_rb_path)
clf = model_init(Classifier(), params.clf_adda_rb_path)
# Train source model for adda
print(
"====== Robust training source encoder and classifier in SVHN domain ======"
)
if not (src_encoder.pretrained and clf.pretrained
and params.model_trained):
src_encoder, clf = train_src_robust(src_encoder, clf, svhn_data_loader)
# Eval source model
print("====== Evaluating classifier for SVHN domain ======")
eval_tgt_robust(src_encoder, clf, svhn_data_loader_eval)
# Train target encoder
print("====== Robust training encoder for MNIST domain ======")
# Initialize target encoder's weights with those of the source encoder
if not tgt_encoder.pretrained:
tgt_encoder.load_state_dict(src_encoder.state_dict())
if not (tgt_encoder.pretrained and critic.pretrained
and params.model_trained):
tgt_encoder = train_tgt_adda(src_encoder,
tgt_encoder,
critic,
svhn_data_loader,
mnist_data_loader,
robust=True)
# Eval target encoder on test set of target dataset
print("====== Ealuating classifier for encoded MNIST domain ======")
print("-------- Source only --------")
eval_tgt_robust(src_encoder, clf, mnist_data_loader_eval)
print("-------- Domain adaption --------")
eval_tgt_robust(tgt_encoder, clf, mnist_data_loader_eval)
def main():
# init random seed
init_random_seed(params.manual_seed)
# Load dataset
svhn_data_loader = get_svhn(split='train', download=True)
svhn_data_loader_eval = get_svhn(split='test', download=True)
mnist_data_loader = get_mnist(train=True, download=True)
mnist_data_loader_eval = get_mnist(train=False, download=True)
# Model init DANN
tgt_encoder = model_init(Encoder(), params.tgt_encoder_dann_rb_path)
critic = model_init(
Discriminator(in_dims=params.d_in_dims,
h_dims=params.d_h_dims,
out_dims=params.d_out_dims), params.disc_dann_rb_path)
clf = model_init(Classifier(), params.clf_dann_rb_path)
# Train models
print(
"====== Training source encoder and classifier in SVHN and MNIST domains ======"
)
if not (tgt_encoder.pretrained and clf.pretrained and critic.pretrained
and params.model_trained):
tgt_encoder, clf, critic = train_dann(tgt_encoder,
clf,
critic,
svhn_data_loader,
mnist_data_loader,
mnist_data_loader_eval,
robust=True)
# Eval target encoder on test set of target dataset
print(
"====== Evaluating classifier for encoded SVHN and MNIST domains ======"
)
print("-------- SVHN domain --------")
eval_tgt_robust(tgt_encoder, clf, svhn_data_loader_eval)
print("-------- MNIST adaption --------")
eval_tgt_robust(tgt_encoder, clf, mnist_data_loader_eval)
def main():
# init random seed
init_random_seed(params.manual_seed)
# Load dataset
mnist_data_loader = get_mnist(train=True, download=True)
mnist_data_loader_eval = get_mnist(train=False, download=True)
usps_data_loader = get_usps(train=True, download=True)
usps_data_loader_eval = get_usps(train=False, download=True)
# Model init DANN
tgt_encoder = model_init(Encoder(), params.tgt_encoder_dann_rb_path)
critic = model_init(Discriminator(), params.disc_dann_rb_path)
clf = model_init(Classifier(), params.clf_dann_rb_path)
# Train models
print(
"====== Robust Training source encoder and classifier in MNIST and USPS domains ======"
)
if not (tgt_encoder.pretrained and clf.pretrained and critic.pretrained
and params.model_trained):
tgt_encoder, clf, critic = train_dann(tgt_encoder,
clf,
critic,
mnist_data_loader,
usps_data_loader,
usps_data_loader_eval,
robust=False)
# Eval target encoder on test set of target dataset
print(
"====== Evaluating classifier for encoded MNIST and USPS domains ======"
)
print("-------- MNIST domain --------")
eval_tgt_robust(tgt_encoder, clf, critic, mnist_data_loader_eval)
print("-------- USPS adaption --------")
eval_tgt_robust(tgt_encoder, clf, critic, usps_data_loader_eval)
print("====== Pseudo labeling on USPS domain ======")
pseudo_label(tgt_encoder, clf, "usps_train_pseudo", usps_data_loader)
# Init a new model
tgt_encoder = model_init(Encoder(), params.tgt_encoder_path)
clf = model_init(Classifier(), params.clf_path)
# Load pseudo labeled dataset
usps_pseudo_loader = get_usps(train=True, download=True, get_pseudo=True)
print("====== Standard training on USPS domain with pseudo labels ======")
if not (tgt_encoder.pretrained and clf.pretrained):
train_src_adda(tgt_encoder, clf, usps_pseudo_loader, mode='ADV')
print("====== Evaluating on USPS domain with real labels ======")
eval_tgt(tgt_encoder, clf, usps_data_loader_eval)
tgt_encoder = model_init(Encoder(), params.tgt_encoder_rb_path)
clf = model_init(Classifier(), params.clf_rb_path)
print("====== Robust training on USPS domain with pseudo labels ======")
if not (tgt_encoder.pretrained and clf.pretrained):
train_src_robust(tgt_encoder, clf, usps_pseudo_loader, mode='ADV')
print("====== Evaluating on USPS domain with real labels ======")
eval_tgt(tgt_encoder, clf, usps_data_loader_eval)