def run():
# load source dataset
src_data_loader = get_data_loader(params.src_dataset)
src_data_loader_eval = get_data_loader(params.src_dataset, train=False)
# load models
src_encoder = init_model(net=LeNetEncoder(),
restore=params.src_encoder_restore)
src_classifier = init_model(net=LeNetClassifier(),
restore=params.src_classifier_restore)
# pre-train source model
print("=== Training classifier for source domain ===")
print(">>> Source Encoder <<<")
im, _ = next(iter(src_data_loader))
summary(src_encoder, input_size=im[0].size())
print(">>> Source Classifier <<<")
print(src_classifier)
if not (src_encoder.restored and src_classifier.restored and
params.src_model_trained):
src_encoder, src_classifier = train_src(
src_encoder, src_classifier, src_data_loader)
# eval source model
print("=== Evaluating classifier for source domain ===")
eval_src(src_encoder, src_classifier, src_data_loader_eval)
def office():
init_random_seed(params.manual_seed)
# load dataset
src_data_loader = get_data_loader(params.src_dataset)
src_data_loader_eval = get_data_loader(params.src_dataset, train=False)
tgt_data_loader = get_data_loader(params.tgt_dataset)
tgt_data_loader_eval = get_data_loader(params.tgt_dataset, train=False)
# load models
src_encoder = init_model(net=LeNetEncoder(),
restore=params.src_encoder_restore)
src_classifier = init_model(net=LeNetClassifier(),
restore=params.src_classifier_restore)
tgt_encoder = init_model(net=LeNetEncoder(),
restore=params.tgt_encoder_restore)
critic = init_model(Discriminator(input_dims=params.d_input_dims,
hidden_dims=params.d_hidden_dims,
output_dims=params.d_output_dims),
restore=params.d_model_restore)
if not (src_encoder.restored and src_classifier.restored and
params.src_model_trained):
src_encoder, src_classifier = train_src(
src_encoder, src_classifier, src_data_loader)
# eval source model
# print("=== Evaluating classifier for source domain ===")
# eval_src(src_encoder, src_classifier, src_data_loader_eval)
# train target encoder by GAN
# init weights of target encoder with those of source encoder
if not tgt_encoder.restored:
tgt_encoder.load_state_dict(src_encoder.state_dict())
if not (tgt_encoder.restored and critic.restored and
params.tgt_model_trained):
tgt_encoder = train_tgt(src_encoder, tgt_encoder, critic,
src_data_loader, tgt_data_loader)
# eval target encoder on test set of target dataset
print(">>> domain adaption <<<")
acc = eval_tgt(tgt_encoder, src_classifier, tgt_data_loader_eval)
return acc
def experiments(exp):
#print(exp, case, affine, num_epochs)
# init random seed
#params.d_learning_rate = lr_d
#params.c_learning_rate = lr_c
init_random_seed(params.manual_seed)
# load dataset
src_dataset, tgt_dataset = exp.split('_')
src_data_loader = get_data_loader(src_dataset)
src_data_loader_eval = get_data_loader(src_dataset, train=False)
tgt_data_loader = get_data_loader(tgt_dataset)
tgt_data_loader_eval = get_data_loader(tgt_dataset, train=False)
# load models
src_encoder = init_model(net=LeNetEncoder(),
restore=params.src_encoder_restore,
exp=exp)
src_classifier = init_model(net=LeNetClassifier(),
restore=params.src_classifier_restore,
exp=exp)
tgt_encoder = init_model(net=LeNetEncoder(),
restore=params.tgt_encoder_restore,
exp=exp)
critic = init_model(Discriminator(input_dims=params.d_input_dims,
hidden_dims=params.d_hidden_dims,
output_dims=params.d_output_dims),
exp=exp,
restore=params.d_model_restore)
# train source model
print("=== Training classifier for source domain ===")
print(">>> Source Encoder <<<")
print(src_encoder)
print(">>> Source Classifier <<<")
print(src_classifier)
if not (src_encoder.restored and src_classifier.restored
and params.src_model_trained):
src_encoder, src_classifier = train_src(exp, src_encoder,
src_classifier,
src_data_loader,
src_data_loader_eval)
# eval source model
print("=== Evaluating classifier for source domain ===")
evaluation(src_encoder, src_classifier, src_data_loader_eval)
# train target encoder by GAN
print("=== Training encoder for target domain ===")
print(">>> Target Encoder <<<")
print(tgt_encoder)
print(">>> Critic <<<")
print(critic)
# init weights of target encoder with those of source encoder
if not tgt_encoder.restored:
tgt_encoder.load_state_dict(src_encoder.state_dict())
if not (tgt_encoder.restored and critic.restored
and params.tgt_model_trained):
tgt_encoder = train_tgt(exp, src_encoder, tgt_encoder, critic,
src_classifier, src_data_loader,
tgt_data_loader, tgt_data_loader_eval)
# eval target encoder on test set of target dataset
print("=== Evaluating classifier for encoded target domain ===")
print(">>> source only <<<")
evaluation(src_encoder, src_classifier, tgt_data_loader_eval)
print(">>> domain adaption <<<")
evaluation(tgt_encoder, src_classifier, tgt_data_loader_eval)
restore=params.tgt_encoder_restore)
critic = init_model(Discriminator(input_dims=params.d_input_dims,
hidden_dims=params.d_hidden_dims,
output_dims=params.d_output_dims),
restore=params.d_model_restore)
# train source model
print("=== Training classifier for source domain ===")
print(">>> Source Encoder <<<")
print(src_encoder)
print(">>> Source Classifier <<<")
print(src_classifier)
if not (src_encoder.restored and src_classifier.restored
and params.src_model_trained):
src_encoder, src_classifier = train_src(src_encoder, src_classifier,
src_data_loader)
# eval source model
# print("=== Evaluating classifier for source domain ===")
# eval_src(src_encoder, src_classifier, src_data_loader_eval)
# train target encoder by GAN
print("=== Training encoder for target domain ===")
print(">>> Target Encoder <<<")
print(tgt_encoder)
print(">>> Critic <<<")
print(critic)
# init weights of target encoder with those of source encoder
if not tgt_encoder.restored:
tgt_encoder.load_state_dict(src_encoder.state_dict())
train=False)
# load models
src_encoder = init_model(net=Encoder(), restore=params.src_encoder_restore)
src_classifier = init_model(net=Classifier(),
restore=params.src_classifier_restore)
tgt_encoder = init_model(net=Encoder(), restore=params.tgt_encoder_restore)
critic = init_model(Discriminator(), restore=params.d_model_restore)
# train source model
print("=== Training classifier for source domain ===")
if not (src_encoder.restored and src_classifier.restored
and params.src_model_trained):
src_encoder, src_classifier = train_src(src_encoder, src_classifier,
src_data_loader,
tgt_data_loader, params)
# eval source model
print("=== Evaluating classifier for source domain ===")
eval(src_encoder, src_classifier, src_data_loader)
print("=== Evaluating classifier for target domain ===")
eval(src_encoder, src_classifier, tgt_data_loader)
# train target encoder by GAN
print("=== Training encoder for target domain ===")
# init weights of target encoder with those of source encoder
if not tgt_encoder.restored:
tgt_encoder.load_state_dict(src_encoder.state_dict())
# restore=None)
discriminator = init_model(net=Discriminator_img(nc=cfg.inputc),
restore=None)
# train source model
print("=== Training classifier for source domain ===")
print(">>> Source Encoder <<<")
print(src_encoder)
print(">>> Source Classifier <<<")
print(src_classifier)
# pre-train source encoder classifier
if not (src_encoder.restored and src_classifier.restored
and cfg.src_model_trained):
src_encoder, src_classifier = train_src(src_encoder, src_classifier,
src_data_loader,
tgt_data_loader_eval)
tgt_classifier = init_model(net=LeNetClassifier(ncls=cfg.ncls),
restore=cfg.src_classifier_restore)
# pre-train source generator
if not (generator.restored and cfg.src_model_trained):
generator = train_src_rec(src_encoder, src_classifier, generator,
src_data_loader)
generator = init_model(net=LeNetGenerator(input_dims=cfg.g_input_dims,
outputc=cfg.inputc),
restore=cfg.src_generator_restore)
# eval source model
print("=== Evaluating classifier for source domain ===")
eval_func(src_encoder, src_classifier, src_data_loader_eval)
def main():
# argument parsing
parser = argparse.ArgumentParser(description="Specify Params for Experimental Setting")
parser.add_argument('--src', type=str, default="books", choices=["books", "dvd", "electronics", "kitchen"],
help="Specify src dataset")
parser.add_argument('--tgt', type=str, default="dvd", choices=["books", "dvd", "electronics", "kitchen"],
help="Specify tgt dataset")
parser.add_argument('--enc_train', default=False, action='store_true',
help='Train source encoder')
parser.add_argument('--seqlen', type=int, default=200,
help="Specify maximum sequence length")
parser.add_argument('--patience', type=int, default=5,
help="Specify patience of early stopping for pretrain")
parser.add_argument('--num_epochs_pre', type=int, default=200,
help="Specify the number of epochs for pretrain")
parser.add_argument('--log_step_pre', type=int, default=10,
help="Specify log step size for pretrain")
parser.add_argument('--eval_step_pre', type=int, default=5,
help="Specify eval step size for pretrain")
parser.add_argument('--save_step_pre', type=int, default=100,
help="Specify save step size for pretrain")
parser.add_argument('--num_epochs', type=int, default=100,
help="Specify the number of epochs for adaptation")
parser.add_argument('--log_step', type=int, default=10,
help="Specify log step size for adaptation")
parser.add_argument('--save_step', type=int, default=100,
help="Specify save step size for adaptation")
parser.add_argument('--model_root', type=str, default='snapshots',
help="model_root")
args = parser.parse_args()
# argument setting
print("=== Argument Setting ===")
print("src: " + args.src)
print("tgt: " + args.tgt)
print("enc_train: " + str(args.enc_train))
print("seqlen: " + str(args.seqlen))
print("patience: " + str(args.patience))
print("num_epochs_pre: " + str(args.num_epochs_pre))
print("log_step_pre: " + str(args.log_step_pre))
print("eval_step_pre: " + str(args.eval_step_pre))
print("save_step_pre: " + str(args.save_step_pre))
print("num_epochs: " + str(args.num_epochs))
print("log_step: " + str(args.log_step))
print("save_step: " + str(args.save_step))
# init random seed
init_random_seed(manual_seed)
# preprocess data
print("=== Processing datasets ===")
src_train = read_data('./data/processed/' + args.src + '/train.txt')
src_test = read_data('./data/processed/' + args.src + '/test.txt')
tgt_train = read_data('./data/processed/' + args.tgt + '/train.txt')
tgt_test = read_data('./data/processed/' + args.tgt + '/test.txt')
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
src_train_sequences = []
src_test_sequences = []
tgt_train_sequences = []
tgt_test_sequences = []
for i in range(len(src_train.review)): # 1587
tokenized_text = tokenizer.tokenize(src_train.review[i])
indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text)
src_train_sequences.append(indexed_tokens)
for i in range(len(src_test.review)):
tokenized_text = tokenizer.tokenize(src_test.review[i])
indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text)
src_test_sequences.append(indexed_tokens)
for i in range(len(tgt_train.review)):
tokenized_text = tokenizer.tokenize(tgt_train.review[i])
indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text)
tgt_train_sequences.append(indexed_tokens)
for i in range(len(tgt_test.review)):
tokenized_text = tokenizer.tokenize(tgt_test.review[i])
indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text)
tgt_test_sequences.append(indexed_tokens)
# load dataset
src_data_loader = get_data_loader(src_train_sequences, src_train.label, args.seqlen)
src_data_loader_eval = get_data_loader(src_test_sequences, src_test.label, args.seqlen)
tgt_data_loader = get_data_loader(tgt_train_sequences, tgt_train.label, args.seqlen)
tgt_data_loader_eval = get_data_loader(tgt_test_sequences, tgt_test.label, args.seqlen)
print("=== Datasets successfully loaded ===")
# load models
src_encoder = init_model(BERTEncoder(),
restore=src_encoder_restore)
src_classifier = init_model(BERTClassifier(),
restore=src_classifier_restore)
tgt_encoder = init_model(BERTEncoder(),
restore=tgt_encoder_restore)
critic = init_model(Discriminator(),
restore=d_model_restore)
# freeze encoder params
if not args.enc_train:
for param in src_encoder.parameters():
param.requires_grad = True
# train source model
print("=== Training classifier for source domain ===")
src_encoder, src_classifier = train_src(
args, src_encoder, src_classifier, src_data_loader, src_data_loader_eval)
# eval source model
print("=== Evaluating classifier for source domain ===")
eval_src(src_encoder, src_classifier, src_data_loader_eval)
# train target encoder by GAN
# print("=== Training encoder for target domain ===")
# if not (tgt_encoder.restored and critic.restored and
# tgt_model_trained):
# tgt_encoder = train_tgt(args, src_encoder, tgt_encoder, critic,
# src_data_loader, tgt_data_loader)
# eval target encoder on test set of target dataset
print("=== Evaluating classifier for encoded target domain ===")
print(">>> source only <<<")
eval_tgt(src_encoder, src_classifier, tgt_data_loader_eval)
print(">>> domain adaption <<<")
eval_tgt(src_encoder, src_classifier, tgt_data_loader_eval)
if torch.cuda.device_count() > 1:
encoder = torch.nn.DataParallel(encoder)
class_classifier = torch.nn.DataParallel(cls_classifier)
domain_encoder = torch.nn.DataParallel(dom_classifier)
encoder = init_model(encoder, restore=param.encoder_restore)
cls_classifier = init_model(cls_classifier,
restore=param.cls_classifier_restore)
dom_classifier = init_model(dom_classifier,
restore=param.dom_classifier_restore)
# freeze encoder params
if torch.cuda.device_count() > 1:
for params in encoder.module.encoder.embeddings.parameters():
params.requires_grad = False
else:
for params in encoder.encoder.embeddings.parameters():
params.requires_grad = False
# train source model
print("=== Training classifier for source domain ===")
src_encoder, cls_classifier, dom_classifier = train_src(
args, encoder, cls_classifier, dom_classifier, src_data_loader,
tgt_data_loader, src_data_loader_eval)
# eval target encoder on lambda0.1 set of target dataset
print("=== Evaluating classifier for encoded target domain ===")
print(">>> DANN adaption <<<")
eval_tgt(encoder, cls_classifier, tgt_data_loader)
hidden_dims=params.d_hidden_dims,
output_dims=params.d_output_dims),
restore=params.d_model_restore)
# train source model
print("=== Training classifier for source domain ===")
print(">>> Source Encoder <<<")
print(src_encoder)
print(">>> Source Classifier <<<")
print(src_classifier)
if not (src_encoder.restored and src_classifier.restored and
params.src_model_trained):
src_encoder, src_classifier = train_src(
src_encoder,
src_classifier,
src_data_loader, dataset_name="EMOTION")
# eval source model
print("=== Evaluating classifier for source domain ===")
eval_src(src_encoder, src_classifier, src_data_loader_eval)
# train target encoder by GAN
print("=== Training encoder for target domain ===")
print(">>> Target Encoder <<<")
print(tgt_encoder)
print(">>> Critic <<<")
print(critic)
# init weights of target encoder with those of source encoder
if not tgt_encoder.restored:
restore=params.tgt_encoder_restore)
critic = init_model(Discriminator(input_dims=params.d_input_dims,
hidden_dims=params.d_hidden_dims,
output_dims=params.d_output_dims),
restore=params.d_model_restore)
# train source model
print("=== Training classifier for source domain ===")
print(">>> Source Encoder <<<")
print(src_encoder)
print(">>> Source Classifier <<<")
print(src_classifier)
src_encoder, src_classifier = train_src(src_encoder,
src_classifier,
src_data_loader,
dataset_name=params.src_dataset)
# eval source model
print("=== Evaluating classifier for source domain ===")
eval_src(src_encoder, src_classifier, src_data_loader_eval)
# train target encoder by GAN
print("=== Training encoder for target domain ===")
print(">>> Target Encoder <<<")
print(tgt_encoder)
print(">>> Critic <<<")
print(critic)
# init weights of target encoder with those of source encoder
if not tgt_encoder.restored:
src_encoder_restore = path_snapshot + '/source-encoder-' + str(
s) + '.pt'
src_attention_restore = path_snapshot + '/source-attn-' + str(
s) + '.pt'
src_classifier_restore = path_snapshot + '/source-classifier-' + str(
s) + '.pt'
src_data_loader = get_data_loader(params.src_dataset)
src_data_loader_eval = get_data_loader(params.src_dataset, train=False)
src_encoder = init_model(net=PatchEncoder(),
restore=src_encoder_restore)
attn_list = []
classifier_list = []
for j in range(0, 1):
src_attention = init_model(net=PatchAttention(),
restore=src_attention_restore)
attn_list.append(src_attention)
src_classifier = init_model(net=PatchClassifier(),
restore=src_classifier_restore)
classifier_list.append(src_classifier)
model_root_src = path_snapshot
if not os.path.exists(model_root_src):
os.makedirs(model_root_src)
print(i)
if not (src_encoder.restored and params.src_model_trained):
src_encoder, attn_list, classifier_list = train_src(
src_encoder, attn_list, classifier_list, src_data_loader,
model_root_src, i)
src_classifier = init_model(BERTClassifier(),
restore=param.src_classifier_restore)
tgt_encoder = init_model(BERTEncoder(), restore=param.tgt_encoder_restore)
critic = init_model(Discriminator(), restore=param.d_model_restore)
# freeze encoder params
if not args.enc_train:
for param in src_encoder.parameters():
param.requires_grad = False
# train source model
print("=== Training classifier for source domain ===")
# if not (src_encoder.restored and src_classifier.restored and
# param.src_model_trained):
src_encoder, src_classifier = train_src(args, src_encoder, src_classifier,
src_data_loader,
src_data_loader_eval)
# eval source model
print("=== Evaluating classifier for source domain ===")
eval_src(src_encoder, src_classifier, src_data_loader_eval)
# train target encoder by GAN
print("=== Training encoder for target domain ===")
if not (tgt_encoder.restored and critic.restored
and param.tgt_model_trained):
tgt_encoder = train_tgt(args, src_encoder, tgt_encoder, critic,
src_data_loader, tgt_data_loader)
# eval target encoder on test set of target dataset
print("=== Evaluating classifier for encoded target domain ===")
def main():
args = get_arguments()
# init random seed
init_random_seed(manual_seed)
src_data_loader, src_data_loader_eval, tgt_data_loader, tgt_data_loader_eval = get_dataset(args)
# argument setting
print("=== Argument Setting ===")
print("src: " + args.src)
print("tgt: " + args.tgt)
print("patience: " + str(args.patience))
print("num_epochs_pre: " + str(args.num_epochs_pre))
print("eval_step_pre: " + str(args.eval_step_pre))
print("save_step_pre: " + str(args.save_step_pre))
print("num_epochs: " + str(args.num_epochs))
print("src encoder lr: " + str(args.lr))
print("tgt encoder lr: " + str(args.t_lr))
print("critic lr: " + str(args.c_lr))
print("batch_size: " + str(args.batch_size))
# load models
src_encoder_restore = "snapshots/src-encoder-adda-{}.pt".format(args.src)
src_classifier_restore = "snapshots/src-classifier-adda-{}.pt".format(args.src)
tgt_encoder_restore = "snapshots/tgt-encoder-adda-{}.pt".format(args.src)
d_model_restore = "snapshots/critic-adda-{}.pt".format(args.src)
src_encoder = init_model(BERTEncoder(),
restore=src_encoder_restore)
src_classifier = init_model(BERTClassifier(),
restore=src_classifier_restore)
tgt_encoder = init_model(BERTEncoder(),
restore=tgt_encoder_restore)
critic = init_model(Discriminator(),
restore=d_model_restore)
# no, fine-tune BERT
# if not args.enc_train:
# for param in src_encoder.parameters():
# param.requires_grad = False
if torch.cuda.device_count() > 1:
print('Let\'s use {} GPUs!'.format(torch.cuda.device_count()))
src_encoder = nn.DataParallel(src_encoder)
src_classifier = nn.DataParallel(src_classifier)
tgt_encoder = nn.DataParallel(tgt_encoder)
critic = nn.DataParallel(critic)
# train source model
print("=== Training classifier for source domain ===")
src_encoder, src_classifier = train_src(
args, src_encoder, src_classifier, src_data_loader, src_data_loader_eval)
# eval source model
print("=== Evaluating classifier for source domain ===")
eval_src(src_encoder, src_classifier, src_data_loader_eval)
# train target encoder by GAN
print("=== Training encoder for target domain ===")
if not (tgt_encoder.module.restored and critic.module.restored and
tgt_model_trained):
tgt_encoder = train_tgt(args, src_encoder, tgt_encoder, critic,
src_data_loader, tgt_data_loader)
# eval target encoder on test set of target dataset
print("Evaluate tgt test data on src encoder: {}".format(args.tgt))
eval_tgt(src_encoder, src_classifier, tgt_data_loader_eval)
print("Evaluate tgt test data on tgt encoder: {}".format(args.tgt))
eval_tgt(tgt_encoder, src_classifier, tgt_data_loader_eval)
# train source model
print("=== Training classifier for source domain ===")
print(">>> Source Encoder <<<")
print(src_encoder)
print(">>> Source Classifier <<<")
print(src_classifier)
if not (src_encoder.restored and src_classifier.restored
and params.src_model_trained):
if os.path.exists(params.checkpoints_pretrain):
checkpoints = pickle.load(open(params.checkpoints_pretrain, 'rb'))
else:
print("no checkpoint in %s!" % params.checkpoints_pretrain)
checkpoints = None
src_encoder, src_classifier = train_src(src_encoder, src_classifier,
src_data_loader,
src_data_loader_validate,
checkpoints)
# eval source model
#print("=== Evaluating source classifier for source domain ===")
#eval_src(src_encoder, src_classifier, src_data_loader_test)
########################## evaluate on unseen target ##########################
data = DataModel(os.path.join(params.target_dataroot, params.target_train))
tgt_data_loader_train = DataLoader(data,
batch_size=params.batch_size,
shuffle=True,
num_workers=params.num_workers,
collate_fn=collate_fn)
