def main(num):
# Generate configuration files depending on experiment being run
utils.generate_config_files("motiv", num)
# Loads the correct configuration file
config_file = "config/motiv/config_{}.json".format(num)
print(config_file)
# Read config file to option
config = cfg.read_config(cfg.load_config(config_file))
opt, meta = cfg.get_parameters(config)
# Set the random seeds
torch.manual_seed(opt.train.static.seed)
random.seed(opt.train.static.seed)
if config.gpu_mode:
torch.cuda.manual_seed_all(opt.train.static.seed)
# Where to find the data
splits = ["train", "dev", "test"]
opt.train.dynamic.epoch = 0
print("Loading Data")
categories = opt.data.categories
path = "data/motiv_sent_none/processed/{}/{}.pickle".format(
opt.exp, utils.make_name_string(opt.data))
data_loader = data.make_data_loader(opt, categories)
loaded = data_loader.load_data(path)
print(data_loader.sequences["train"]["total"].size(0))
data_loader.opt = opt
data_loader.batch_size = opt.train.dynamic.bs
print("Done.")
# Initialize text_encoder
text_encoder = TextEncoder(config.encoder_path, config.bpe_path)
special = [data.start_token, data.end_token]
special += ["<{}>".format(cat) for cat in categories]
special += [data.blank_token]
text_encoder.encoder = data_loader.vocab_encoder
text_encoder.decoder = data_loader.vocab_decoder
opt.data.maxe1 = data_loader.max_event
opt.data.maxe2 = data_loader.max_effect
opt.data.maxr = data.atomic_data.num_delimiter_tokens["category"]
n_special = len(special)
n_ctx = opt.data.maxe1 + opt.data.maxe2
n_vocab = len(text_encoder.encoder) + n_ctx
print(data_loader.__dict__.keys())
opt.net.vSize = n_vocab
print("Building Model")
model = models.make_model(
opt, n_vocab, n_ctx, n_special,
load=(opt.net.init=="pt"))
print("Done.")
print("Files will be logged at: {}".format(
utils.make_name(opt, prefix="results/losses/",
is_dir=True, eval_=True)))
data_loader.reset_offsets("train")
# Get number of examples
data.set_max_sizes(data_loader)
if config.gpu_mode:
print("Pushing to GPU: {}".format(config.gpu_index))
cfg.device = config.gpu_index
cfg.do_gpu = True
torch.cuda.set_device(cfg.device)
if config.multigpu:
model = models.multi_gpu(
model, config.gpu_indices).cuda()
else:
model.cuda(cfg.device)
print("Done.")
print("Training")
optimizer = OpenAIAdam(model.parameters(),
lr=opt.train.dynamic.lr,
schedule=opt.train.static.lrsched,
warmup=opt.train.static.lrwarm,
t_total=meta.iterations,
b1=opt.train.static.b1,
b2=opt.train.static.b2,
e=opt.train.static.e,
l2=opt.train.static.l2,
vector_l2=opt.train.static.vl2,
max_grad_norm=opt.train.static.clip)
scorers = ["bleu", "rouge", "cider"]
trainer = train.make_trainer(
opt, meta, data_loader, model, optimizer)
trainer.set_evaluator(opt, model, data_loader)
trainer.run()
def main(num):
# Generate configuration files depending on experiment being run
#utils.generate_config_files("atomic", num)
# Loads the correct configuration file
config_file = "config/atomic/config_{}.json".format(num)
print(config_file)
# Read config file to option
config = cfg.read_config(cfg.load_config(config_file))
opt, meta = cfg.get_parameters(config)
# Set the random seeds
torch.manual_seed(opt.train.static.seed)
random.seed(opt.train.static.seed)
if config.gpu_mode:
torch.cuda.manual_seed_all(opt.train.static.seed)
# Where to find the data
splits = ["train", "dev", "test"]
opt.train.dynamic.epoch = 0
print("Loading Data")
categories = opt.data.categories
x = "data/atomic/processed/generation/categories_oEffect#oReact#oWant#xAttr#xEffect#xIntent#xNeed#xReact#xWant-maxe1_17-maxe2_36-maxr_1.pickle"
path = x.format(opt.exp, utils.make_name_string(opt.data))
print(path)
data_loader = data.make_data_loader(opt, categories)
loaded = data_loader.load_data(path)
print(data_loader.sequences["train"]["total"].size(0))
data_loader.opt = opt
data_loader.batch_size = opt.train.dynamic.bs
print("Done.")
# Initialize text_encoder
#text_encoder = TextEncoder(config.encoder_path, config.bpe_path)
text_encoder = GPT2Tokenizer.from_pretrained('gpt2')
special = [data.start_token, data.end_token]
special += ["<{}>".format(cat) for cat in categories]
special += [data.blank_token]
special_tokens = {
"cls_token": "[CLS]",
"unk_token": "[UNK]"
} #, "mask": '["MASK"]',"separator": '["SEP"]', "start_of_sentence": '["SOS"]', "end_of_sentence": '["EOS"]'}
text_encoder = GPT2Tokenizer.from_pretrained("gpt2",
cls_token="[CLS]",
unk_token="[UNK]",
mask='["MASK"]',
separator='["SEP"]',
start_of_sentence='["SOS"]',
end_of_sentence='["EOS"]')
text_encoder.add_special_tokens(special_tokens)
text_encoder.encoder = data_loader.vocab_encoder
text_encoder.decoder = data_loader.vocab_decoder
opt.data.maxe1 = data_loader.max_event
opt.data.maxe2 = data_loader.max_effect
opt.data.maxr = data.atomic_data.num_delimiter_tokens["category"]
n_special = len(special)
n_ctx = opt.data.maxe1 + opt.data.maxe2
n_vocab = len(text_encoder.encoder) + n_ctx
print(data_loader.__dict__.keys())
opt.net.vSize = n_vocab
print("Building Model")
model = models.make_model(opt,
n_vocab,
n_ctx,
n_special,
load=(opt.net.init == "pt"))
model.resize_token_embeddings(len(text_encoder))
print("Done.")
print("Files will be logged at: {}".format(
utils.make_name(opt, prefix="results/losses/", is_dir=True,
eval_=True)))
data_loader.reset_offsets("train")
# Get number of examples
data.set_max_sizes(data_loader)
if config.gpu_mode:
print("Pushing to GPU: {}".format(config.gpu_index))
cfg.device = config.gpu_index
cfg.do_gpu = True
torch.cuda.set_device(cfg.device)
if config.multigpu:
model = models.multi_gpu(model, config.gpu_indices).cuda()
else:
model.cuda(cfg.device)
print("Done.")
print("Training")
optimizer = OpenAIAdam(model.parameters(),
lr=opt.train.dynamic.lr,
schedule=opt.train.static.lrsched,
warmup=opt.train.static.lrwarm,
t_total=meta.iterations,
b1=opt.train.static.b1,
b2=opt.train.static.b2,
e=opt.train.static.e,
l2=opt.train.static.l2,
vector_l2=opt.train.static.vl2,
max_grad_norm=opt.train.static.clip)
scorers = ["bleu", "rouge", "cider"]
trainer = train.make_trainer(opt, meta, data_loader, model, optimizer)
trainer.set_generator(opt, model, data_loader)
trainer.set_evaluator(opt, model, data_loader)
trainer.run()
print("Done.")
if config.gpu_mode:
print("Pushing to GPU: {}".format(config.gpu_index))
cfg.device = int(config.gpu_index)
cfg.do_gpu = True
torch.cuda.device(cfg.device)
model.cuda(cfg.device)
print("Done.")
print("Training")
optimizer = OpenAIAdam(model.parameters(),
lr=config.train.dynamic.lr,
schedule=config.train.static.lrsched,
warmup=config.train.static.lrwarm,
t_total=meta.iterations,
b1=config.train.static.b1,
b2=config.train.static.b2,
e=config.train.static.e,
l2=config.train.static.l2,
vector_l2=config.train.static.vl2,
max_grad_norm=config.train.static.clip)
scorers = ["bleu", "rouge", "cider"]
trainer = train.make_trainer(
config, meta, data_loader, model, optimizer)
trainer.set_evaluator(config, model, data_loader)
#import pdb; pdb.set_trace()
trainer.run()
def main(num, LoaderPath=""):
# Generate configuration files depending on experiment being run
utils.generate_config_files("atomic", num)
# Loads the correct configuration file
config_file = "config/atomic/config_{}.json".format(num)
print(config_file)
# Read config file to option
config = cfg.read_config(cfg.load_config(config_file))
opt, meta = cfg.get_parameters(
config
) ##################opt.exp & opt.data used for path of data loader
#########ADRIAN ADDED
print("FULL OPT DICT: ")
for x in opt:
print(x)
#for y in opt[x]:
#print (y,':',opt[x][y])
#######
# Set the random seeds
torch.manual_seed(opt.train.static.seed)
random.seed(opt.train.static.seed)
if config.gpu_mode:
torch.cuda.manual_seed_all(opt.train.static.seed)
# Where to find the data
splits = ["train", "dev", "test"]
opt.train.dynamic.epoch = 0
print("Loading Data")
categories = opt.data.categories
#####ADRIAN ADDED
print("OPT.exp: " + str(opt.exp))
print("OPT.data dictionary as string: " + utils.make_name_string(opt.data))
######
path = "data/atomic/processed/{}/{}.pickle".format(
opt.exp,
utils.make_name_string(opt.data)) ##############how is path made??
data_loader = data.make_data_loader(
opt, categories) #just copies init of data loader
#OLD#loaded = data_loader.load_data(path)#######DATA LOADER PATH
#NEW TRY
#loaded = data_loader.load_data("MULTI_COMET_DATA\It50k_MaxE50\Slovene\Slo_Loader_It50k_maxE50.pickle")#######DATA LOADER PATH
if (LoaderPath == ""):
#OLD#
loaded = data_loader.load_data(path) #######DATA LOADER PATH
else:
#NEW#
loaded = data_loader.load_data(LoaderPath)
############
print(data_loader.sequences["train"]["total"].size(0))
data_loader.opt = opt
data_loader.batch_size = opt.train.dynamic.bs
print("Done.")
# Initialize text_encoder
text_encoder = TextEncoder(config.encoder_path, config.bpe_path)
special = [data.start_token, data.end_token]
special += ["<{}>".format(cat) for cat in categories]
special += [data.blank_token]
text_encoder.encoder = data_loader.vocab_encoder
text_encoder.decoder = data_loader.vocab_decoder
opt.data.maxe1 = data_loader.max_event
opt.data.maxe2 = data_loader.max_effect
opt.data.maxr = data.atomic_data.num_delimiter_tokens["category"]
n_special = len(special)
n_ctx = opt.data.maxe1 + opt.data.maxe2
n_vocab = len(text_encoder.encoder) + n_ctx
print(data_loader.__dict__.keys())
opt.net.vSize = n_vocab
print("Building Model")
model = models.make_model(opt,
n_vocab,
n_ctx,
n_special,
load=(opt.net.init == "pt"))
print("Done.")
print("Files will be logged at: {}".format(
utils.make_name(opt, prefix="results/losses/", is_dir=True,
eval_=True)))
data_loader.reset_offsets("train")
# Get number of examples
data.set_max_sizes(data_loader)
if config.gpu_mode:
print("Pushing to GPU: {}".format(config.gpu_index))
cfg.device = config.gpu_index
cfg.do_gpu = True
torch.cuda.set_device(cfg.device)
if config.multigpu:
model = models.multi_gpu(model, config.gpu_indices).cuda()
else:
model.cuda(cfg.device)
print("Done.")
print("Training")
optimizer = OpenAIAdam(model.parameters(),
lr=opt.train.dynamic.lr,
schedule=opt.train.static.lrsched,
warmup=opt.train.static.lrwarm,
t_total=meta.iterations,
b1=opt.train.static.b1,
b2=opt.train.static.b2,
e=opt.train.static.e,
l2=opt.train.static.l2,
vector_l2=opt.train.static.vl2,
max_grad_norm=opt.train.static.clip)
scorers = ["bleu", "rouge", "cider"]
trainer = train.make_trainer(opt, meta, data_loader, model, optimizer)
trainer.set_evaluator(opt, model, data_loader)
trainer.run()
