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)
