def main(args):
print(args)
if args.seed != -1:
torch.manual_seed(args.seed)
np.random.seed(args.seed)
pattern_specs = OrderedDict(sorted(([int(y) for y in x.split("-")] for x in args.patterns.split("_")),
key=lambda t: t[0]))
n = args.num_train_instances
mlp_hidden_dim = args.mlp_hidden_dim
num_mlp_layers = args.num_mlp_layers
dev_vocab = vocab_from_text(args.vd)
print("Dev vocab size:", len(dev_vocab))
vocab, embeddings, word_dim = \
read_embeddings(args.embedding_file, dev_vocab)
num_padding_tokens = max(list(pattern_specs.keys())) - 1
dev_input, dev_text = read_docs(args.vd, vocab, num_padding_tokens=num_padding_tokens)
dev_labels = read_labels(args.vl)
dev_data = list(zip(dev_input, dev_labels))
if n is not None:
dev_data = dev_data[:n]
num_classes = len(set(dev_labels))
print("num_classes:", num_classes)
semiring = \
MaxPlusSemiring if args.maxplus else (
LogSpaceMaxTimesSemiring if args.maxtimes else ProbSemiring
)
if args.use_rnn:
rnn = Rnn(word_dim,
args.hidden_dim,
cell_type=LSTM,
gpu=args.gpu)
else:
rnn = None
model = SoftPatternClassifier(pattern_specs, mlp_hidden_dim, num_mlp_layers, num_classes, embeddings, vocab,
semiring, args.bias_scale_param, args.gpu, rnn=rnn, pre_computed_patterns=None)
if args.gpu:
print("Cuda!")
model.to_cuda(model)
state_dict = torch.load(args.input_model)
else:
state_dict = torch.load(args.input_model, map_location=lambda storage, loc: storage)
# Loading model
model.load_state_dict(state_dict)
interpret_documents(model, args.batch_size, dev_data, dev_text, args.ofile, args.max_doc_len)
return 0
def main():
n = None
mlp_hidden_dim = 25
num_mlp_layers = 2
validation_data_file = "./soft_patterns/data/test.data"
dev_vocab = vocab_from_text(validation_data_file)
print("Dev vocab size:", len(dev_vocab))
embedding_file = "./soft_patterns/glove.6B.50d.txt"
vocab, embeddings, word_dim = read_embeddings(embedding_file, dev_vocab)
seed = 100
torch.manual_seed(seed)
np.random.seed(seed)
patterns = "5-50_4-50_3-50_2-50"
pattern_specs = OrderedDict(
sorted(([int(y) for y in x.split("-")] for x in patterns.split("_")),
key=lambda t: t[0]))
num_padding_tokens = max(list(pattern_specs.keys())) - 1
dev_input, _ = read_docs(validation_data_file,
vocab,
num_padding_tokens=num_padding_tokens)
validation_label_file = "./soft_patterns/data/test.labels"
dev_labels = read_labels(validation_label_file)
dev_data = list(zip(dev_input, dev_labels))
num_classes = len(set(dev_labels))
print("num_classes:", num_classes)
semiring = Semiring(zeros, ones, torch.add, torch.mul, sigmoid, identity)
rnn = None
model = SoftPatternClassifier(pattern_specs, mlp_hidden_dim,
num_mlp_layers, num_classes, embeddings,
vocab, semiring, 0.1, False, rnn, None,
False, 0, False, None, None)
input_model = "./soft_patterns/output/model_9.pth"
state_dict = torch.load(input_model,
map_location=lambda storage, loc: storage)
model.load_state_dict(state_dict)
test_acc = evaluate_accuracy(model, dev_data, 1, False)
print("Test accuracy: {:>8,.3f}%".format(100 * test_acc))
return 0
def main(args):
print(args)
n = args.num_train_instances
if args.seed != -1:
torch.manual_seed(args.seed)
np.random.seed(args.seed)
dev_vocab = vocab_from_text(args.vd)
print("Dev vocab:", len(dev_vocab))
train_vocab = vocab_from_text(args.td)
print("Train vocab:", len(train_vocab))
dev_vocab |= train_vocab
vocab, embeddings, word_dim = \
read_embeddings(args.embedding_file, dev_vocab)
num_padding_tokens = 1
dev_input, dev_text = read_docs(args.vd,
vocab,
num_padding_tokens=num_padding_tokens)
dev_labels = read_labels(args.vl)
dev_data = list(zip(dev_input, dev_labels))
np.random.shuffle(dev_data)
train_input, _ = read_docs(args.td,
vocab,
num_padding_tokens=num_padding_tokens)
train_labels = read_labels(args.tl)
print("training instances:", len(train_input))
num_classes = len(set(train_labels))
# truncate data (to debug faster)
train_data = list(zip(train_input, train_labels))
np.random.shuffle(train_data)
print("num_classes:", num_classes)
if n is not None:
train_data = train_data[:n]
dev_data = dev_data[:n]
dropout = None if args.td is None else args.dropout
# TODO: GRU doesn't work yet
cell_type = LSTM # GRU if args.gru else LSTM
model = AveragingRnnClassifier(args.hidden_dim,
args.mlp_hidden_dim,
args.num_mlp_layers,
num_classes,
embeddings,
cell_type=cell_type,
gpu=args.gpu)
if args.gpu:
model.to_cuda(model)
model_file_prefix = 'model'
# Loading model
if args.input_model is not None:
state_dict = torch.load(args.input_model)
model.load_state_dict(state_dict)
model_file_prefix = 'model_retrained'
model_save_dir = args.model_save_dir
if model_save_dir is not None:
if not os.path.exists(model_save_dir):
os.makedirs(model_save_dir)
print("Training with", model_file_prefix)
train(train_data,
dev_data,
model,
num_classes,
model_save_dir,
args.num_iterations,
model_file_prefix,
args.learning_rate,
args.batch_size,
args.scheduler,
gpu=args.gpu,
clip=args.clip,
debug=args.debug,
dropout=dropout,
word_dropout=args.word_dropout,
patience=args.patience)
def main(args):
print(args)
pattern_specs = OrderedDict(
sorted(
([int(y) for y in x.split("-")] for x in args.patterns.split("_")),
key=lambda t: t[0]))
pre_computed_patterns = None
if args.pre_computed_patterns is not None:
pre_computed_patterns = read_patterns(args.pre_computed_patterns,
pattern_specs)
pattern_specs = OrderedDict(
sorted(pattern_specs.items(), key=lambda t: t[0]))
n = args.num_train_instances
mlp_hidden_dim = args.mlp_hidden_dim
num_mlp_layers = args.num_mlp_layers
if args.seed != -1:
torch.manual_seed(args.seed)
np.random.seed(args.seed)
dev_vocab = vocab_from_text(args.vd)
print("Dev vocab size:", len(dev_vocab))
train_vocab = vocab_from_text(args.td)
print("Train vocab size:", len(train_vocab))
dev_vocab |= train_vocab
vocab, embeddings, word_dim = \
read_embeddings(args.embedding_file, dev_vocab)
num_padding_tokens = max(list(pattern_specs.keys())) - 1
dev_input, _ = read_docs(args.vd,
vocab,
num_padding_tokens=num_padding_tokens)
dev_labels = read_labels(args.vl)
dev_data = list(zip(dev_input, dev_labels))
np.random.shuffle(dev_data)
num_iterations = args.num_iterations
train_input, _ = read_docs(args.td,
vocab,
num_padding_tokens=num_padding_tokens)
train_labels = read_labels(args.tl)
print("training instances:", len(train_input))
num_classes = len(set(train_labels))
# truncate data (to debug faster)
train_data = list(zip(train_input, train_labels))
np.random.shuffle(train_data)
print("num_classes:", num_classes)
if n is not None:
train_data = train_data[:n]
dev_data = dev_data[:n]
if args.use_rnn:
rnn = Rnn(word_dim, args.hidden_dim, cell_type=LSTM, gpu=args.gpu)
else:
rnn = None
semiring = \
MaxPlusSemiring if args.maxplus else (
LogSpaceMaxTimesSemiring if args.maxtimes else ProbSemiring
)
model = SoftPatternClassifier(pattern_specs, mlp_hidden_dim,
num_mlp_layers, num_classes, embeddings,
vocab, semiring, args.bias_scale_param,
args.gpu, rnn, pre_computed_patterns,
args.no_sl, args.shared_sl, args.no_eps,
args.eps_scale, args.self_loop_scale)
if args.gpu:
model.to_cuda(model)
model_file_prefix = 'model'
# Loading model
if args.input_model is not None:
state_dict = torch.load(args.input_model)
model.load_state_dict(state_dict)
model_file_prefix = 'model_retrained'
model_save_dir = args.model_save_dir
if model_save_dir is not None:
if not os.path.exists(model_save_dir):
os.makedirs(model_save_dir)
print("Training with", model_file_prefix)
train(train_data, dev_data, model, num_classes, model_save_dir,
num_iterations, model_file_prefix, args.learning_rate,
args.batch_size, args.scheduler, args.gpu, args.clip,
args.max_doc_len, args.debug, args.dropout, args.word_dropout,
args.patience)
return 0
def main(args):
print(args)
n = args.num_train_instances
mlp_hidden_dim = args.mlp_hidden_dim
num_mlp_layers = args.num_mlp_layers
dev_vocab = vocab_from_text(args.vd)
print("Dev vocab size:", len(dev_vocab))
vocab, embeddings, word_dim = \
read_embeddings(args.embedding_file, dev_vocab)
if args.seed != -1:
torch.manual_seed(args.seed)
np.random.seed(args.seed)
if args.dan or args.bilstm:
num_padding_tokens = 1
elif args.cnn:
num_padding_tokens = args.window_size - 1
else:
pattern_specs = OrderedDict(sorted(([int(y) for y in x.split("-")] for x in args.patterns.split("_")),
key=lambda t: t[0]))
num_padding_tokens = max(list(pattern_specs.keys())) - 1
dev_input, dev_text = read_docs(args.vd, vocab, num_padding_tokens=num_padding_tokens)
dev_labels = read_labels(args.vl)
dev_data = list(zip(dev_input, dev_labels))
if n is not None:
dev_data = dev_data[:n]
num_classes = len(set(dev_labels))
print("num_classes:", num_classes)
if args.dan:
model = DanClassifier(mlp_hidden_dim,
num_mlp_layers,
num_classes,
embeddings,
args.gpu)
elif args.bilstm:
cell_type = LSTM
model = AveragingRnnClassifier(args.hidden_dim,
mlp_hidden_dim,
num_mlp_layers,
num_classes,
embeddings,
cell_type=cell_type,
gpu=args.gpu)
elif args.cnn:
model = PooledCnnClassifier(args.window_size,
args.num_cnn_layers,
args.cnn_hidden_dim,
num_mlp_layers,
mlp_hidden_dim,
num_classes,
embeddings,
pooling=max_pool_seq,
gpu=args.gpu)
else:
semiring = \
MaxPlusSemiring if args.maxplus else (
LogSpaceMaxTimesSemiring if args.maxtimes else ProbSemiring
)
if args.use_rnn:
rnn = Rnn(word_dim,
args.hidden_dim,
cell_type=LSTM,
gpu=args.gpu)
else:
rnn = None
model = SoftPatternClassifier(pattern_specs, mlp_hidden_dim, num_mlp_layers, num_classes, embeddings, vocab,
semiring, args.bias_scale_param, args.gpu, rnn, None, args.no_sl, args.shared_sl,
args.no_eps, args.eps_scale, args.self_loop_scale)
if args.gpu:
state_dict = torch.load(args.input_model)
else:
state_dict = torch.load(args.input_model, map_location=lambda storage, loc: storage)
model.load_state_dict(state_dict)
if args.gpu:
model.to_cuda(model)
test_acc = evaluate_accuracy(model, dev_data, args.batch_size, args.gpu)
print("Test accuracy: {:>8,.3f}%".format(100*test_acc))
return 0
def main():
patterns = "5-50_4-50_3-50_2-50"
pattern_specs = OrderedDict(sorted(([int(y) for y in x.split("-")] for x in patterns.split("_")), key=lambda t: t[0]))
pre_computed_patterns = None
n = None
mlp_hidden_dim = 25
num_mlp_layers = 2
seed = 100
#Sets the seed for generating random numbers.
torch.manual_seed(seed)
#This method is called when RandomState is initialized.
np.random.seed(seed)
validation_data_file = "./soft_patterns/data/dev.data"
dev_vocab = vocab_from_text(validation_data_file)
# print(dev_vocab.index)
print("Dev vocab size:", len(dev_vocab))
# exit(0)
train_data_file = "./soft_patterns/data/train.data"
train_vocab = vocab_from_text(train_data_file)
print("Train vocab size:", len(train_vocab))
dev_vocab |= train_vocab
embedding_file='./soft_patterns/glove.6B.50d.txt'
vocab, embeddings, word_dim = read_embeddings(embedding_file, dev_vocab)
num_padding_tokens = max(list(pattern_specs.keys())) - 1
dev_input, _ = read_docs(validation_data_file, vocab, num_padding_tokens=num_padding_tokens)
validation_label_file = "./soft_patterns/data/dev.labels"
dev_labels = read_labels(validation_label_file)
dev_data = list(zip(dev_input, dev_labels))
np.random.shuffle(dev_data)
num_iterations = 10
train_input, _ = read_docs(train_data_file, vocab, num_padding_tokens=num_padding_tokens)
train_labels_file = "./soft_patterns/data/train.labels"
train_labels = read_labels(train_labels_file)
print("training instances:", len(train_input))
num_classes = len(set(train_labels))
train_data = list(zip(train_input, train_labels))
np.random.shuffle(train_data)
print("num_classes:", num_classes)
rnn = None
semiring = Semiring(zeros, ones, torch.add, torch.mul, sigmoid, identity)
model = SoftPatternClassifier(pattern_specs, mlp_hidden_dim, num_mlp_layers, num_classes, embeddings, vocab, semiring, 0.1, False, rnn, pre_computed_patterns, False, 0, False, None, None)
model_file_prefix = "model"
model_save_dir = "./soft_patterns/output/"
print("Training with", model_file_prefix)
train(train_data, dev_data, model, num_classes, model_save_dir, num_iterations, model_file_prefix, 0.001, 1, False, False, None, -1,0,0,0, 30)
return 0
