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 main(): args = arguments() # init random seed init_random_seed(manual_seed) src_train_loader, src_test_loader, tgt_train_loader, tgt_test_loader = get_dataset( args) print("=== Datasets successfully loaded ===") src_encoder_restore = "snapshots/src-encoder-{}.pt".format(args.src) src_classifier_restore = "snapshots/src-classifier-{}.pt".format(args.src) # load models src_encoder = init_model(BERTEncoder(), restore=src_encoder_restore) src_classifier = init_model(BERTClassifier(), restore=src_classifier_restore) # 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) # argument setting print("=== Argument Setting ===") print("src: " + args.src) print("tgt: " + args.tgt) print("seqlen: " + str(args.seqlen)) print("num_epochs: " + str(args.num_epochs)) print("batch_size: " + str(args.batch_size)) print("learning_rate: " + str(args.lr)) if 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_no_da(args, src_encoder, src_classifier, src_train_loader, src_test_loader) # eval source model print("Evaluate classifier for source domain: {}".format(args.src)) eval_src(src_encoder, src_classifier, src_test_loader) # eval target encoder on test set of target dataset print("Evaluate classifier for encoded target domain: {}".format(args.tgt)) eval_tgt(src_encoder, src_classifier, tgt_test_loader)
# init random seed init_random_seed(params.manual_seed) # load dataset src_data_loader = get_visda(root=params.data_root, sub_dir='train', split='train') src_data_loader_eval = get_visda(root=params.data_root, sub_dir='train', split='test') tgt_data_loader = get_visda(root=params.data_root, sub_dir='validation', split='train') tgt_data_loader_eval = get_visda(root=params.data_root, sub_dir='validation', split='test') # load models src_encoder = init_model(net=ResNet34Encoder(), restore=params.src_encoder_restore) src_classifier = init_model(net=Classifier(), restore=params.src_classifier_restore) # train source model # print("=== Training classifier for source domain ===") # print(">>> Source Encoder <<<") # print(src_encoder) # print(">>> Source Classifier <<<") # print(src_classifier) # eval source model print("=== Evaluating classifier for source domain ===") eval_src(src_encoder, src_classifier, src_data_loader_eval) # eval target encoder on test set of target dataset print("=== Evaluating classifier for encoded target domain ===") # print(">>> domain adaption <<<") eval_src(src_encoder, src_classifier, tgt_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)
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)