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)
def main(): # init random seed init_random_seed(params.manual_seed) #check the needed dirs of config check_dirs() cudnn.benchmark = True torch.cuda.set_device(params.gpu_id[0]) #set current device print('=== Build model ===') #gpu mode generator = Generator() discriminator = Discriminator() generator = nn.DataParallel(generator, device_ids=params.gpu_id).cuda() discriminator = nn.DataParallel(discriminator, device_ids=params.gpu_id).cuda() # restore trained model if params.generator_restored: generator = restore_model(generator, params.generator_restored) if params.discriminator_restored: discriminator = restore_model(discriminator, params.discriminator_restored) # container of training trainer = Trainer(generator, discriminator) if params.mode == 'train': # data loader print('=== Load data ===') train_dataloader = get_data_loader(params.dataset) print('=== Begin training ===') trainer.train(train_dataloader) print('=== Generate {} images, saving in {} ==='.format( params.num_images, params.save_root)) trainer.generate_images(params.num_images, params.save_root) elif params.mode == 'test': if params.generator_restored: print('=== Generate {} images, saving in {} ==='.format( params.num_images, params.save_root)) trainer.generate_images(params.num_images, params.save_root) else: assert False, '[*]load Generator model first!' else: assert False, "[*]mode must be 'train' or 'test'!"
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
"""Main script for ADDA.""" import params from pretrain import eval_src, train_src from lenet import LeNetClassifier, LeNetEncoder from discriminator import Discriminator from utils import get_data_loader, init_model, init_random_seed from test import eval_tgt from adopt import train_target if __name__ == '__main__': # init random seed 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_dim=params.d_input_dims, hidden_dim=params.d_hidden_dims, output_dim=params.d_output_dims), restore=params.d_model_restore)
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)
import torch.nn as nn import torch.optim as optim import torchvision from data_loader import data_loader from models import get_models from params import * from utils import denormalize, init_random_seed, make_variable if __name__ == '__main__': #################### # 1. setup network # #################### # init random seed init_random_seed() # init models D, G = get_models(num_channels, d_conv_dim, g_conv_dim, z_dim, num_gpu, d_model_restore, g_model_restore) # init optimizer criterion = nn.BCELoss() if torch.cuda.is_available(): criterion.cuda() d_optimizer = optim.Adam(D.parameters(), lr=d_learning_rate, betas=(beta1, beta2)) g_optimizer = optim.Adam(G.parameters(), lr=g_learning_rate, betas=(beta1, beta2))
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)
import re import pyconll import torch from torch import nn from torch.nn import functional as F from torch.utils.data import TensorDataset from torch.utils.data import DataLoader from utils import tokenize_corpus, build_vocabulary, \ character_tokenize, pos_corpus_to_tensor, POSTagger, \ train_eval_loop, predict_with_model, init_random_seed, \ SentenceLevelPOSTagger, StackedConv1d init_random_seed(4) def main(): # Загрузка данных. Разделение на тренировочные и тестовые full = pyconll.load_from_file('./data/postag_sakha.conllu') full_train = full[:1700] full_test = full[1700:] print('Количество тренировочных предложений = ', len(full_train)) print('Количество тестовых предложений = ', len(full_test)) # Посчитаем максимальную длину слова и предложения MAX_SENT_LEN = max(len(sent) for sent in full_train) MAX_ORIG_TOKEN_LEN = max( len(token.form) for sent in full_train for token in sent) print('Наибольшая длина предложения', MAX_SENT_LEN)
def main(): init_random_seed(config.manual_seed) # load data src_data_loader = get_data_loader(config.src_dataset) src_data_loader_eval = get_data_loader(config.src_dataset, train=False) tgt_data_loader = get_data_loader(config.tgt_dataset) tgt_data_loader_eval = get_data_loader(config.tgt_dataset, train=False) # init models src_encoder = init_model(net=VAE(), restore=config.src_encoder_restore) src_classifier = init_model(net=VAE_Classifier(), restore=config.src_classifier_restore) tgt_encoder = init_model(net=VAE(), restore=config.tgt_encoder_restore) tgt_classifier = init_model(net=VAE_Classifier(), restore=config.tgt_classifier_restore) discriminator_one = init_model(net=Discriminator(), restore=config.discriminator_one_restore) discriminator_two = init_model(net=Discriminator(), restore=config.discriminator_two_restore) # init optimizers src_ignored_params = list(map(id, src_encoder.encoder.parameters())) src_base_params = filter(lambda p: id(p) not in src_ignored_params, src_encoder.parameters()) optimizer_src = torch.optim.SGD([ { 'params': src_encoder.encoder.parameters(), 'lr': 1e-4 }, { 'params': src_base_params, 'lr': 1e-3 }, { 'params': src_classifier.parameters(), 'lr': 1e-3 }, ], momentum=0.9) optimizer_tgt = torch.optim.SGD([ { 'params': tgt_encoder.parameters(), 'lr': 1e-5 }, { 'params': tgt_classifier.parameters(), 'lr': 1e-5 }, ], momentum=0.9) optimizer_dis_one = torch.optim.SGD(discriminator_one.parameters(), lr=1e-3, momentum=0.9) optimizer_dis_two = torch.optim.SGD(discriminator_two.parameters(), lr=1e-3, momentum=0.9) if not (src_encoder.restored and src_classifier.restored): print("=== Training classifier for source domain ===") src_encoder, src_classifier = train_src(src_encoder, src_classifier, optimizer_src, src_data_loader, src_data_loader_eval, tgt_data_loader_eval) print("=== Evaluating classifier for source domain ===") evaluate(src_encoder, src_classifier, src_data_loader_eval) evaluate(src_encoder, src_classifier, tgt_data_loader_eval) if not (tgt_encoder.restored and tgt_classifier.restored): print("=== init weights of target encoder and target classifier===") tgt_encoder.load_state_dict(src_encoder.state_dict()) tgt_classifier.load_state_dict(src_classifier.state_dict()) if not (tgt_encoder.restored and discriminator_one.restored): print("=== Training encoder for target domain ===") tgt_encoder, tgt_classifier = train_tgt( src_encoder, tgt_encoder, tgt_classifier, discriminator_one, discriminator_two, optimizer_tgt, optimizer_dis_one, optimizer_dis_two, src_data_loader, tgt_data_loader, tgt_data_loader_eval) print("=== Evaluating classifier for target domain ===") print("--- source only ---") evaluate(src_encoder, src_classifier, tgt_data_loader_eval) print("--- domain adaption ---") evaluate(tgt_encoder, tgt_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)