glove_common_words)
vocab_size = len(np.unique(vocab_token_to_id.keys())[0])
train_instances = index_instances(train_instances, vocab_token_to_id)
val_instances = index_instances(val_instances, vocab_token_to_id)
### TODO(Students) START
# make a config file here as expected by your MyAdvancedModel
config = {'vocab_size': vocab_size, 'embed_dim': args.embed_dim, 'training': True}
### TODO(Students END
model = MyAdvancedModel(**config)
config['type'] = 'advanced'
optimizer = optimizers.Adam()
embeddings = load_glove_embeddings(args.embed_file, args.embed_dim, vocab_id_to_token)
model.embeddings.assign(tf.convert_to_tensor(embeddings))
save_serialization_dir = os.path.join('serialization_dirs', 'advanced_4')
if not os.path.exists(save_serialization_dir):
os.makedirs(save_serialization_dir)
train_output = train(model, optimizer, train_instances, val_instances,
args.epochs, args.batch_size, save_serialization_dir)
config_path = os.path.join(save_serialization_dir, "config.json")
with open(config_path, 'w', encoding='UTF-8') as f:
json.dump(config, f)
vocab_path = os.path.join(save_serialization_dir, "vocab.txt")
save_vocabulary(vocab_id_to_token, vocab_path)
else:
config = {
"pretrained_model_path": args.base_model_dir,
"layer_num": args.layer_num,
"classes_num": 2
}
classifier = ProbingClassifier(**config)
config["type"] = "probing"
train_instances = index_instances(train_instances, vocab_token_to_id)
validation_instances = index_instances(validation_instances,
vocab_token_to_id)
if args.model_name == "main" and args.pretrained_embedding_file:
embeddings = load_glove_embeddings(args.pretrained_embedding_file,
args.embedding_dim,
vocab_id_to_token)
classifier._embeddings.assign(tf.convert_to_tensor(embeddings))
optimizer = optimizers.Adam()
save_serialization_dir = os.path.join("serialization_dirs",
args.model_name + args.suffix_name)
if not os.path.exists(save_serialization_dir):
os.makedirs(save_serialization_dir)
training_output = train(classifier, optimizer, train_instances,
validation_instances, args.num_epochs,
args.batch_size, save_serialization_dir)
classifier = training_output["model"]
metrics = training_output["metrics"]
if args.model_type == 'DAN':
model_config[
'hidden_dim'] = args.embed_dim if args.hidden_dim == -1 else args.hidden_dim
model = DAN(**model_config)
elif args.model_type == 'DFN':
model_config[
'hidden_dim'] = 150 if args.hidden_dim == -1 else args.hidden_dim
model = DFN(**model_config)
else:
model_config[
'hidden_dim'] = args.sequence_length if args.hidden_dim == -1 else args.hidden_dim
model = GRU(**model_config)
if args.embeddings is not None:
model.embeddings.assign(
load_glove_embeddings(args.embeddings, args.embed_dim,
reverse_vocab))
if not os.path.exists(args.checkpoint_path):
os.makedirs(args.checkpoint_path)
elif os.path.exists(os.path.join(args.checkpoint_path,
f'tensorboard_logs')):
shutil.rmtree(os.path.join(args.checkpoint_path, f'tensorboard_logs'))
train_result = train(model, optimizer, train_batches, validation_batches,
args.num_epochs, args.checkpoint_path, model_config,
vocab)
model, metrics, plot_data = train_result['model'], train_result[
'metrics'], train_result['plot_data']
json.dump(
metrics,
open(os.path.join(args.checkpoint_path, f'metrics.json'),
'w',
