def __init__(self, verbose=False, random_seed=None, memory=512, autobatch=False, use_gpu=False):
"""
Create an empty instance for Cube
Before it can be used, you must call @method load with @param language_code set to your target language
"""
self._loaded = False
self._verbose = verbose
import dynet_config
if random_seed != None:
if not isinstance(random_seed, int):
raise Exception ("Random seed must be an integer!")
if random_seed == 0:
print("[Warning] While Python and Numpy's seeds are now set to 0, DyNet uses 0 to reset the seed generator (fully random). Use any non-zero int value to set DyNet to a fixed random seed.")
# set python random seed
import random
random.seed(random_seed)
#set numpy random seed
import numpy as np
np.random.seed(random_seed)
else:
random_seed = 0 # this is the default value for DyNet (meaning full random)
dynet_config.set(mem=memory, random_seed=random_seed, autobatch=autobatch)
if use_gpu:
dynet_config.set_gpu()
def initialize_dynet(title):
import dynet_config
dynet_config.set(random_seed=42,
mem="1536,1536,512,512",
autobatch=True,
requested_gpus=1)
import dynet
time.sleep(2)
def get_dynet():
if bool(os.environ['DYNET_USE_GPU']):
dynet_config.set_gpu()
dynet_config.set(mem=os.environ['DYNET_MEM'],
random_seed=int(os.environ['DYNET_SEED']),
autobatch=int(os.environ['DYNET_AUTOBATCH']),
requested_gpus=int(os.environ['DYNET_GPUS']))
log.info(f"DyNet config: {dynet_config.get()}")
import dynet as dy
return dy
def set_dynet_arguments(self):
self.random.seed(self.args.seed)
kwargs = dict(random_seed=self.args.seed)
if self.args.dynet_mem:
kwargs.update(mem=self.args.dynet_mem)
if self.args.dynet_weight_decay:
kwargs.update(weight_decay=self.args.dynet_weight_decay)
if self.args.dynet_gpus and self.args.dynet_gpus != 1:
kwargs.update(requested_gpus=self.args.dynet_gpus)
if self.args.dynet_autobatch:
kwargs.update(autobatch=True)
dynet_config.set(**kwargs)
if self.args.dynet_gpu:
dynet_config.set_gpu()
def set_dynet_arguments(self):
self.random.seed(self.args.seed)
kwargs = dict(random_seed=self.args.seed)
if self.args.dynet_mem:
kwargs.update(mem=self.args.dynet_mem)
if self.args.dynet_weight_decay:
kwargs.update(weight_decay=self.args.dynet_weight_decay)
if self.args.dynet_gpus and self.args.dynet_gpus != 1:
kwargs.update(requested_gpus=self.args.dynet_gpus)
if self.args.dynet_autobatch:
kwargs.update(autobatch=True)
dynet_config.set(**kwargs)
if self.args.dynet_gpu:
dynet_config.set_gpu()
"""Script for training on the alchemy domain.
Attributes:
"""
import sys
import os
import dynet_config
dynet_config.set(mem=2048,
autobatch="--dynet-autobatch" in sys.argv \
or "--dynet-autobatch=1" in sys.argv)
import dynet as dy
import argparse
from data import load_data
from alchemy_fsa import AlchemyFSA
from alchemy_state import AlchemyState
from alchemy_state_encoder import AlchemyStateEncoder
from evaluation import utterance_accuracy, interaction_accuracy, attention_analysis
from model import ConstrainedContextSeq2SeqEmbeddings
from reinforcement_learning import reinforcement_learning, reward_with_shaping
from supervised_learning import train_and_evaluate
from args import interpret_args
from vocabulary import EOS, NO_ARG
from util import shaping
LOG_DIR = 'logs-alchemy'
# Alchemy-specific methods.
import sys
from random import shuffle
import datetime
import dynet_config
dynet_config.set(autobatch=1)
import dynet as dy
import numpy as np
import matplotlib.pyplot as plt
import pickle
EPOCHS = 5
LSTM_LAYERS = 1
LSTM_INPUT_DIM = 50
LSTM_STATE_DIM = 50
MIN_WORD_APPEARANCE = 2
uncommon_words = set()
SUFF_UUUNKKK = 'SUFF_UUUNKKK'
PRE_UUUNKKK = 'PRE_UUUNKKK'
UUUNKKK = 'UUUNKKK'
UNK_NUM = 'UNK_num'
UNK_ALLCAP = 'UNK_ALLCAP'
UNK_CAP_START = 'UNK_CapStart'
def load_sentences(data):
"""
Converting file to array of sentences
:param data:
:return: sen_arr
import csv import random import pickle import scipy import pandas as pd import numpy as np seed = 10 import dynet_config # Declare GPU as the default device type dynet_config.set_gpu() # Set some parameters manualy dynet_config.set(mem=400, random_seed=seed) # Initialize dynet import using above configuration in the current scope import dynet as dy from utils.io_utils import IOUtils from utils.nlp_utils import NLPUtils from sklearn.metrics import roc_auc_score, average_precision_score from sklearn.model_selection import KFold random.seed(seed) np.random.seed(seed) # %% class Data:
import networkx as nx
import random
import numpy as np
import dynet_config
#dynet_config.set_gpu()
dynet_config.set(mem=4028)
import dynet as dy
numberOfGraphs = 80
#inicializace premennych
graph = {}
graph_mapping = {}
nodes = 0
big_nodes = {}
index = 0
for number in range(0, numberOfGraphs):
#nacitanie jednotlivych grafov
graf = nx.read_gml('./graphs/graph' + str(number) + '.gml')
mapping_name = {}
mapping_int = {}
mapping = {}
i = 0
for node in list(graf.nodes()):
#vystrihnutoe mena z labelu
separated = node.split("\n")[0]
nodes = nodes + 1
# namapujem mena na cisla a naopak aby som pak vedel pridat mena k vstupom a vystupom
mapping[node] = separated
mapping_int[i] = separated
mapping_name[separated] = i
def main():
# Configuration file processing
argparser = argparse.ArgumentParser()
argparser.add_argument('--config_file', default='../configs/debug.cfg')
argparser.add_argument('--continue_training', action='store_true',
help='Load model Continue Training')
argparser.add_argument('--name', default='experiment',
help='The name of the experiment.')
argparser.add_argument('--model', default='s2s',
help='s2s: seq2seq-head-selection-model'
's2tDFS: seq2tree-DFS-decoder-model')
argparser.add_argument('--gpu', default='0', help='GPU ID (-1 to cpu)')
args, extra_args = argparser.parse_known_args()
cfg = IniConfigurator(args.config_file, extra_args)
# Logger setting
logger = dual_channel_logger(
__name__,
file_path=cfg.LOG_FILE,
file_model='w',
formatter='%(asctime)s - %(levelname)s - %(message)s',
time_formatter='%m-%d %H:%M')
from eval.script_evaluator import ScriptEvaluator
# DyNet setting
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
import dynet_config
dynet_config.set(mem=cfg.DYNET_MEM, random_seed=cfg.DYNET_SEED)
dynet_config.set_gpu()
import dynet as dy
from models.token_representation import TokenRepresentation
from antu.nn.dynet.seq2seq_encoders import DeepBiRNNBuilder, orthonormal_VanillaLSTMBuilder
from models.graph_nn_decoder import GraphNNDecoder
from models.jackknife_decoder import JackKnifeGraphNNDecoder
# Build the dataset of the training process
# Build data reader
data_reader = PTBReader(
field_list=['word', 'tag', 'head', 'rel'],
root='0\t**root**\t_\t**rcpos**\t**rpos**\t_\t0\t**rrel**\t_\t_',
spacer=r'[\t]',)
# Build vocabulary with pretrained glove
vocabulary = Vocabulary()
g_word, _ = glove_reader(cfg.GLOVE)
pretrained_vocabs = {'glove': g_word}
vocabulary.extend_from_pretrained_vocab(pretrained_vocabs)
# Setup datasets
datasets_settings = {'train': DatasetSetting(cfg.TRAIN, True),
'dev': DatasetSetting(cfg.DEV, False),
'test': DatasetSetting(cfg.TEST, False), }
datasets = PTBDataset(vocabulary, datasets_settings, data_reader)
counters = {'word': Counter(), 'tag': Counter(), 'rel': Counter()}
datasets.build_dataset(counters, no_pad_namespace={'rel'}, no_unk_namespace={'rel'})
# Build model
# Parameter
pc = dy.ParameterCollection()
LR = 0.0005
trainer = dy.AdamTrainer(pc, LR, cfg.ADAM_BETA1, cfg.ADAM_BETA2, cfg.EPS)
# Token Representation Layer
token_repre = TokenRepresentation(pc, cfg, datasets.vocabulary, include_pos=True)
# BiLSTM Encoder Layer
#encoder = BiaffineAttention()
#encoder = MultiHeadedAttention(pc, 10, token_repre.token_dim)
#encoder = MultiLayerMultiHeadAttention(pc, 10, token_repre.token_dim, num_layers=1)
#encoder = MyMultiHeadAttention(None, 6, token_repre.token_dim, 32, 32, model=pc)
#encoder = LabelAttention(None, token_repre.token_dim, 128, 128, 112, 128, use_resdrop=True, q_as_matrix=False, residual_dropout=0.1, attention_dropout=0.1, d_positional=None, model=pc)
# encoder = Encoder(None, token_repre.token_dim,
# num_layers=1, num_heads=2, d_kv = 32, d_ff=1024, d_l=112,
# d_positional=None,
# num_layers_position_only=0,
# relu_dropout=0.1, residual_dropout=0.1, attention_dropout=0.1,
# use_lal=True,
# lal_d_kv=128,
# lal_d_proj=128,
# lal_resdrop=True,
# lal_pwff=True,
# lal_q_as_matrix=False,
# lal_partitioned=True,
# model=pc)
#encoder = ScaledDotProductAttention(pc, 10)
encoder = DeepBiRNNBuilder(pc, cfg.ENC_LAYERS, token_repre.token_dim, cfg.ENC_H_DIM, orthonormal_VanillaLSTMBuilder)
# GNN Decoder Layer
decoder = GraphNNDecoder(pc, cfg, datasets.vocabulary)
#decoder = JackKnifeGraphNNDecoder(pc, cfg, datasets.vocabulary)
# PTB Evaluator
my_eval = ScriptEvaluator(['Valid', 'Test'], datasets.vocabulary)
#dy.save(cfg.LAST_FILE, [token_repre, encoder, decoder])
#exit(0)
# Build Training Batch
def cmp(ins):
return len(ins['word'])
train_batch = datasets.get_batches('train', cfg.TRAIN_BATCH_SIZE, True, cmp, True)
valid_batch = list(datasets.get_batches('dev', cfg.TEST_BATCH_SIZE, False, cmp, False))
test_batch = list(datasets.get_batches('test', cfg.TEST_BATCH_SIZE, False, cmp, False))
#print('-----------------------')
# print('TRAIN BATCH IS: ')
# # print(train_batch)
# indexes, masks, truth = train_batch.__next__()
# print(indexes)
# print('------------------',end='\n\n\n\n\n\n\n')
# print(len(indexes))
# exit(0)
# exit(0)
# for k in indexes:
# print(k)
#print(indexes)
#print(masks)
# Train model
BEST_DEV_LAS = BEST_DEV_UAS = BEST_ITER = 0
cnt_iter = -cfg.WARM * cfg.GRAPH_LAYERS
valid_loss = [[] for i in range(cfg.GRAPH_LAYERS+3)]
logger.info("Experiment name: %s" % args.name)
SHA = os.popen('git log -1 | head -n 1 | cut -c 8-13').readline().rstrip()
logger.info('Git SHA: %s' % SHA)
while cnt_iter < cfg.MAX_ITER:
print(cnt_iter, cfg.MAX_ITER)
#dy.renew_cg()
dy.renew_cg(immediate_compute = True, check_validity = True)
cnt_iter += 1
indexes, masks, truth = train_batch.__next__()
vectors = token_repre(indexes, True)
#vectors = encoder(vectors, np.array(masks['1D']).T)
#print(vectors.npvalue)
#vectors= encoder(vectors, vectors, vectors, np.array(masks['1D']).T)
#vectors= encoder(vectors, vectors, vectors, np.array(masks['1D']).T, cfg.RNN_DROP)
vectors = encoder(vectors, None, cfg.RNN_DROP, cfg.RNN_DROP, np.array(masks['1D']).T, False, True)
loss, part_loss = decoder(vectors, masks, truth, cnt_iter, True, True)
for i, l in enumerate([loss]+part_loss):
valid_loss[i].append(l.value())
loss.backward()
trainer.learning_rate = LR*cfg.LR_DECAY**(max(cnt_iter, 0)/cfg.LR_ANNEAL)
#trainer.learning_rate = cfg.LR*cfg.LR_DECAY**(max(cnt_iter, 0)/cfg.LR_ANNEAL)
trainer.update()
if cnt_iter % cfg.VALID_ITER: continue
# Validation
for i in range(len(valid_loss)):
valid_loss[i] = str(round(np.mean(valid_loss[i]), 2))
avg_loss = ', '.join(valid_loss)
logger.info("")
logger.info("Iter: %d-%d, Avg_loss: %s, LR (%f), Best (%d)" %
(cnt_iter/cfg.VALID_ITER, cnt_iter, avg_loss,
trainer.learning_rate, BEST_ITER))
valid_loss = [[] for i in range(cfg.GRAPH_LAYERS+3)]
my_eval.clear('Valid')
for indexes, masks, truth in valid_batch:
dy.renew_cg()
vectors = token_repre(indexes, False)
vectors = encoder(vectors, np.array(masks['1D']).T)
#vectors= encoder(vectors, vectors, vectors, np.array(masks['1D']).T)
#vectors = encoder(vectors, vectors, vectors, np.array(masks['1D']).T, cfg.RNN_DROP)
#vectors = encoder(vectors, None, cfg.RNN_DROP, cfg.RNN_DROP, np.array(masks['1D']).T, False, False)
pred = decoder(vectors, masks, None, cnt_iter, False, True)
my_eval.add_truth('Valid', truth)
my_eval.add_pred('Valid', pred)
dy.save(cfg.LAST_FILE, [token_repre, encoder, decoder])
if my_eval.evaluation('Valid', cfg.PRED_DEV, cfg.DEV):
BEST_ITER = cnt_iter/cfg.VALID_ITER
os.system('cp %s.data %s.data' % (cfg.LAST_FILE, cfg.BEST_FILE))
os.system('cp %s.meta %s.meta' % (cfg.LAST_FILE, cfg.BEST_FILE))
# Just record test result
my_eval.clear('Test')
for indexes, masks, truth in test_batch:
dy.renew_cg()
vectors = token_repre(indexes, False)
vectors = encoder(vectors, np.array(masks['1D']).T)
#vectors= encoder(vectors, vectors, vectors, np.array(masks['1D']).T)
#vectors = encoder(vectors, vectors, vectors, np.array(masks['1D']).T, cfg.RNN_DROP)
#vectors = encoder(vectors, None, cfg.RNN_DROP, cfg.RNN_DROP, np.array(masks['1D']).T, False, False)
pred = decoder(vectors, masks, None, cnt_iter, False, True)
my_eval.add_truth('Test', truth)
my_eval.add_pred('Test', pred)
my_eval.evaluation('Test', cfg.PRED_TEST, cfg.TEST)
my_eval.print_best_result('Valid')
# Final Test
test_pc = dy.ParameterCollection()
token_repre, encoder, decoder = dy.load(cfg.BEST_FILE, test_pc)
my_eval.clear('Test')
for indexes, masks, truth in test_batch:
dy.renew_cg()
vectors = token_repre(indexes, False)
vectors = encoder(vectors, np.array(masks['1D']).T)
#vectors= encoder(vectors, vectors, vectors, np.array(masks['1D']).T)
#vectors = encoder(vectors, vectors, vectors, np.array(masks['1D']).T, cfg.RNN_DROP)
#vectors = encoder(vectors, None, cfg.RNN_DROP, cfg.RNN_DROP, np.array(masks['1D']).T, False, False)
pred = decoder(vectors, masks, None, 0, False, True)
my_eval.add_truth('Test', truth)
my_eval.add_pred('Test', pred)
my_eval.evaluation('Test', cfg.PRED_TEST, cfg.TEST)
import numpy as np
import string, random
from collections import Counter
import getopt, sys
import pickle
import dynet_config
dynet_config.set(
mem=16384,
autobatch=True, # utilize autobatching
random_seed=1978 # simply for reproducibility here
)
import dynet as dy
import datetime
import math
def load_pretrained_embeddings(path_to_file, take):
embedding_size = 300
embedding_matrix = None
lookup = {"<unk>": 0}
c = 0
with open(path_to_file, "r") as f:
delimiter = " "
for line in f:
if (take and c <= take) or not take:
# split line
line_split = line.rstrip().split(delimiter)
# extract word and vector
word = line_split[0]
vector = np.array([float(i) for i in line_split[1:]])
return parser
# Train a fragment based model using XR training.
if __name__ == "__main__":
parser = train_command_parser()
args = parser.parse_args()
dev = aspects_sent_convert(read_file_lines(args.dev))
test = aspects_sent_convert(read_file_lines(args.test), no_conflicts=True)
W2I, vecs = read_glove(args.embpath)
model_path = "models/" + args.model_path
random.seed(args.seed)
np.random.seed(args.seed)
import dynet_config
dynet_config.set(random_seed=args.seed)
from import_dy import dy
dyparams = dy.DynetParams()
dyparams.set_autobatch(True)
model = dy.ParameterCollection()
from models import BiLSTM
from train_funcs import *
network = BiLSTM(1, 300, 150, W2I, model, vecs)
if args.train is not None:
train = aspects_sent_convert(read_file_lines(args.train))
if not os.path.exists(model_path):
os.makedirs(model_path)
from io_utils import read_yaml
joint_config = read_yaml('joint_config.yaml')
data_config = read_yaml('data_config.yaml')
import numpy as np
import random
import dynet_config
print('seed:', joint_config['random_seed'])
random.seed(joint_config['random_seed'])
np.random.seed(joint_config['random_seed'])
dynet_config.set(autobatch=1,
mem='4096',
random_seed=joint_config['random_seed'])
import dynet as dy
import nn
import ops
from dy_utils import ParamManager as pm
from dy_utils import AdamTrainer
from event_eval import EventEval
from io_utils import to_set, get_logger
from shift_reduce import ShiftReduce
logger = get_logger('transition', log_dir='log', log_name='trains.log')
sent_vec_dim = 0
if joint_config['use_sentence_vec']:
train_sent_file = data_config['train_sent_file']
test_sent_file = data_config['test_sent_file']
# -*- coding:utf-8 -*-
from __future__ import division, print_function, absolute_import
import numpy as np
import dynet_config
dynet_config.set(mem=32, random_seed=1234)
import dynet as dy
class Model(object):
def __init__(self, hp, params=None, embs=None):
# Set hyperparameters.
dim_uni = hp['DIM_UNI']
dim_bi = hp['DIM_BI']
dim_ctype = hp['DIM_CTYPE']
dim_word = hp['DIM_WORD']
dim_tag_emb = hp['DIM_TAGEMB']
size_uni = hp['VOCAB_SIZE_UNI']
size_bi = hp['VOCAB_SIZE_BI']
size_word = hp['VOCAB_SIZE_WORD']
size_postags = hp['VOCAB_SIZE_POSTAG']
lr = hp['LEARNING_RATE']
ws = hp['WINDOW_SIZE']
layers = hp['LAYERS']
dim_hidden = hp['DIM_HIDDEN']
self.dropout_rate = hp['DROPOUT_RATE']
# Build a word segmentation model and a POS-tagging model simultaneously.
model = dy.ParameterCollection()
"""Simplest possible neural language model:
use word w_i to predict word w_(i + 1)
"""
import os
import pickle
from time import clock
from math import exp
from matplotlib import pyplot as plt
from matplotlib import patches
import dynet_config
dynet_config.set(random_seed=42, autobatch=1)
dynet_config.set_gpu(True)
import dynet as dy
N_GRAM_SIZE = 1
MAX_EPOCHS = 20
BATCH_SIZE = 32
HIDDEN_DIM = 32
USE_UNLABELED = False
VOCAB_SIZE = 4748
def make_batches(data, batch_size):
batches = []
batch = []
for pair in data:
if len(batch) == batch_size:
batches.append(batch)
batch = []
def init_config():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--dynet-mem", default=1000, type=int)
parser.add_argument("--dynet-seed", default=5783287, type=int)
parser.add_argument("--dynet-gpu")
parser.add_argument("--model_name", type=str, default=None)
parser.add_argument("--eval_folder", type=str, default="../eval")
parser.add_argument("--lang", default=None, help="the target language")
parser.add_argument("--train_ensemble", default=False, action="store_true")
parser.add_argument(
"--full_data_path",
type=str,
default=None,
help=
"when train_ensemble is true, this one is the full data path from which to load vocabulary."
)
parser.add_argument("--train_path", default=None, type=str)
# parser.add_argument("--train_path", default="../datasets/english/debug_train.bio", type=str)
parser.add_argument("--monolingual_data_path", default=None, type=str)
parser.add_argument("--dev_path",
default="../datasets/english/eng.dev.bio.conll",
type=str)
parser.add_argument("--test_path",
default="../datasets/english/eng.test.bio.conll",
type=str)
parser.add_argument("--new_test_path",
default="../datasets/english/eng.test.bio.conll",
type=str)
parser.add_argument("--new_test_conll",
default="../datasets/english/eng.test.bio.conll",
type=str)
parser.add_argument("--save_to_path", default="../saved_models/")
parser.add_argument("--load_from_path", default=None)
parser.add_argument("--cap_ratio_path", default=None, type=str)
parser.add_argument("--non_ent_path", default=None, type=str)
parser.add_argument("--min_edit_dist", default=-1, type=int)
parser.add_argument("--train_filename_path", default=None, type=str)
parser.add_argument("--dev_filename_path", default=None, type=str)
parser.add_argument("--test_filename_path", default=None, type=str)
parser.add_argument("--gold_pos_test_filename_path",
default=None,
type=str)
# oromo specific argument
# No matter orm_norm or orm_lower, the char representation is from the original word
parser.add_argument("--lower_case_model_path", type=str, default=None)
parser.add_argument("--train_lowercase_oromo",
default=False,
action="store_true")
parser.add_argument(
"--oromo_normalize",
default=False,
action="store_true",
help=
"if train lowercase model, not sure if norm also helps, this would loss a lot of information"
)
parser.add_argument("--model_arc",
default="char_cnn",
choices=[
"char_cnn", "char_birnn", "char_birnn_cnn", "sep",
"sep_cnn_only", "char_birnn_attn"
],
type=str)
parser.add_argument("--tag_emb_dim", default=50, type=int)
parser.add_argument("--pos_emb_dim", default=64, type=int)
parser.add_argument("--char_emb_dim", default=30, type=int)
parser.add_argument("--word_emb_dim", default=100, type=int)
parser.add_argument("--cnn_filter_size", default=30, type=int)
parser.add_argument("--cnn_win_size", default=3, type=int)
parser.add_argument("--rnn_type",
default="lstm",
choices=['lstm', 'gru'],
type=str)
parser.add_argument("--hidden_dim",
default=200,
type=int,
help="token level rnn hidden dim")
parser.add_argument("--char_hidden_dim",
default=25,
type=int,
help="char level rnn hidden dim")
parser.add_argument("--layer", default=1, type=int)
parser.add_argument("--lm_obj", default=False, action="store_true")
parser.add_argument("--lm_llama", default=False, action="store_true")
parser.add_argument("--lm_param", default=0.5, type=float)
parser.add_argument(
"--replace_unk_rate",
default=0.0,
type=float,
help=
"uses when not all words in the test data is covered by the pretrained embedding"
)
parser.add_argument("--remove_singleton",
default=False,
action="store_true")
parser.add_argument("--map_pretrain", default=False, action="store_true")
parser.add_argument("--map_dim", default=100, type=int)
parser.add_argument("--pretrain_fix", default=False, action="store_true")
parser.add_argument(
"--output_dropout_rate",
default=0.5,
type=float,
help="dropout applied to the output of birnn before crf")
parser.add_argument(
"--emb_dropout_rate",
default=0.3,
type=float,
help="dropout applied to the input of token-level birnn")
parser.add_argument("--valid_freq", default=500, type=int)
parser.add_argument("--tot_epochs", default=100, type=int)
parser.add_argument("--batch_size", default=10, type=int)
parser.add_argument("--init_lr", default=0.015, type=float)
parser.add_argument("--lr_decay", default=False, action="store_true")
parser.add_argument("--decay_rate",
default=0.05,
action="store",
type=float)
parser.add_argument("--patience", default=3, type=int)
parser.add_argument("--tagging_scheme",
default="bio",
choices=["bio", "bioes"],
type=str)
parser.add_argument(
"--data_aug",
default=False,
action="store_true",
help=
"If use data_aug, the train_path should be the combined training file")
parser.add_argument("--aug_lang",
default="english",
help="the language to augment the dataset")
parser.add_argument("--aug_lang_train_path", default=None, type=str)
parser.add_argument("--tgt_lang_train_path",
default="../datasets/english/eng.train.bio.conll",
type=str)
parser.add_argument("--pretrain_emb_path", type=str, default=None)
parser.add_argument("--res_discrete_feature",
default=False,
action="store_true",
help="residual use of discrete features")
parser.add_argument("--feature_birnn_hidden_dim",
default=50,
type=int,
action="store")
parser.add_argument("--use_discrete_features",
default=False,
action="store_true",
help="David's indicator features")
parser.add_argument("--split_hashtag",
default=False,
action="store_true",
help="indicator of preceding hashtags")
parser.add_argument("--cap",
default=False,
action="store_true",
help="capitalization feature")
parser.add_argument("--feature_dim",
type=int,
default=10,
help="dimension of discrete features")
parser.add_argument("--use_brown_cluster",
default=False,
action="store_true")
parser.add_argument("--brown_cluster_path",
action="store",
type=str,
help="path to the brown cluster features")
parser.add_argument("--brown_cluster_num",
default=0,
type=int,
action="store")
parser.add_argument("--brown_cluster_dim",
default=30,
type=int,
action="store")
parser.add_argument("--use_gazatter", default=False, action="store_true")
parser.add_argument("--use_morph", default=False, action="store_true")
parser.add_argument("--use_pos", default=False, action="store_true")
parser.add_argument("--pos_emb_file", default=None, type=str)
parser.add_argument("--pos_train_file", default=None, type=str)
parser.add_argument("--pos_dev_file", default=None, type=str)
parser.add_argument("--pos_test_file", default=None, type=str)
parser.add_argument("--gold_file", default=None, type=str)
parser.add_argument("--gold_test_file", default=None, type=str)
# CRF decoding
parser.add_argument(
"--interp_crf_score",
default=False,
action="store_true",
help="if True, interpolate between the transition and emission score.")
# post process arguments
parser.add_argument("--label_prop", default=False, action="store_true")
parser.add_argument("--confidence_num", default=2, type=str)
parser.add_argument("--author_file", default=None, type=str)
parser.add_argument("--lookup_file", default=None, type=str)
parser.add_argument("--freq_ngram", default=20, type=int)
parser.add_argument("--stop_word_file", default=None, type=str)
parser.add_argument("--isLr", default=False, action="store_true")
parser.add_argument("--valid_on_full", default=False, action="store_true")
parser.add_argument("--valid_using_split",
default=False,
action="store_true")
parser.add_argument("--setEconll",
type=str,
default=None,
help="path to the full setE conll file")
parser.add_argument("--setEconll_10",
type=str,
default=None,
help="path to the 10% setE conll file")
parser.add_argument(
"--score_file",
type=str,
default=None,
help="path to the scoring file for full setE conll file")
parser.add_argument(
"--score_file_10",
type=str,
default=None,
help="path to the scoring file for 10% setE conll file")
parser.add_argument("--gold_setE_path", type=str, default="../ner_score/")
# Use trained model to test
parser.add_argument(
"--mode",
default="train",
type=str,
choices=[
"train", "test_2", "test_1", "ensemble", "pred_ensemble",
"test_new"
],
help=
"test_1: use one model; test_2: use lower case model and normal model to test oromo; "
"ensemble: CRF ensemble; pred_ensemble: ensemble prediction results")
parser.add_argument("--ensemble_model_paths",
type=str,
help="each line in this file is the path to one model")
# Partial CRF
parser.add_argument("--use_partial", default=False, action="store_true")
# Active Learning
parser.add_argument("--ngram", default=2, type=int)
parser.add_argument("--to_annotate", type=str, default="./annotate.txt")
parser.add_argument("--entropy_threshold", type=float, default=None)
parser.add_argument("--use_CFB", default=False, action="store_true")
parser.add_argument("--sumType", default=False, action="store_true")
parser.add_argument("--use_similar_label",
default=False,
action="store_true")
parser.add_argument(
"--SPAN_wise",
default=False,
action="store_true",
help="get span wise scores, even if there are duplicates.")
parser.add_argument("--k",
default=200,
type=int,
help="fixed number of spans to annotate")
parser.add_argument("--clusters",
default=400,
type=int,
help="fixed number of spans to annotate")
parser.add_argument("--debug", type=str)
parser.add_argument("--clusterDetails", type=str)
parser.add_argument("--sqrtnorm", action="store_true", default=False)
parser.add_argument("--activeLearning", action="store_true", default=False)
parser.add_argument("--use_label_propagation",
action="store_true",
default=False)
parser.add_argument("--label_prop_num", type=int, default=5)
parser.add_argument("--cosineAL", action="store_true", default=False)
parser.add_argument("--use_centroid", action="store_true", default=False)
# Format of test output
parser.add_argument("--test_conll", default=False, action="store_true")
parser.add_argument("--fixedVocab",
default=False,
action="store_true",
help="for loading pre-trained model")
parser.add_argument("--fineTune",
default=False,
action="store_true",
help="for loading pre-trained model")
parser.add_argument("--run", default=0, type=int)
parser.add_argument("--misc", default=False, action="store_true")
# Task
parser.add_argument("--task", type=str, default="sigmorph")
#Add multiple languages
parser.add_argument(
"--input_folder",
default="/Users/aditichaudhary/Documents/CMU/SIGMORPH/myNRF/data",
type=str)
parser.add_argument(
"--pos_folder",
default=
"/Users/aditichaudhary/Documents/CMU/SIGMORPH/myNRF/data/POS_Folder",
type=str)
parser.add_argument(
"--lang_codes",
default=
"/Users/aditichaudhary/Documents/CMU/Lorelei/LORELEI_NER/utils/lang_codes.txt",
type=str)
parser.add_argument("--langs", type=str, default="en/hi")
parser.add_argument("--augVocablang", type=str, default=None)
parser.add_argument("--use_langid", action="store_true", default=False)
parser.add_argument("--use_token_langid",
action="store_true",
default=False)
parser.add_argument("--use_char_attention",
action="store_true",
default=False)
parser.add_argument("--use_lang_specific_decoder",
action="store_true",
default=False)
parser.add_argument(
"--multilingual", default=False, action="store_true"
) #TO use data from from multiple languages, currently supported for sigmorph
# Typological features
parser.add_argument("--typology_features_file", type=str, default=None)
parser.add_argument("--use_typology", default=False, action="store_true")
parser.add_argument("--typology_feature_dim", default=10, type=int)
#Lang-Gender Specific
parser.add_argument("--use_gender_specific",
action="store_true",
default=False)
parser.add_argument("--no_gender", action="store_true", default=False)
parser.add_argument("--visualize", action="store_true", default=False)
parser.add_argument("--sent_count", type=int, default=10000000)
parser.add_argument("--myNRF", action='store_true', default=False)
#Use only character-based representations
parser.add_argument("--only_char", action="store_true", default=True)
args = parser.parse_args()
# We are not using uuid to make a unique time stamp, since I thought there is no need to do so when we specify a good model_name.
# If use score_10pct.sh, put the setE_10pct.txt as the dev_path
# If use valid_using_split, set the test_path and setEconll to be the splitted version, this is used for full setE testing
if args.train_ensemble:
# model_name = ens_1_ + original
# set dynet seed manually
ens_no = int(args.model_name.split("_")[1])
# dyparams = dy.DynetParams()
# dyparams.set_random_seed(ens_no + 5783287)
# dyparams.init()
import dynet_config
dynet_config.set(random_seed=ens_no + 5783290)
# if args.cuda:
# dynet_config.set_gpu()
# args.train_path = args.train_path.split(".")[0] + "_" + str(ens_no) + ".conll"
if args.full_data_path is None:
args.full_data_path = args.train_path
args.save_to_path = args.save_to_path + args.model_name + ".model"
# args.gold_setE_path = args.gold_setE_path + args.lang + "_setE_edl.tac"
print(args)
return args
import os
import sys
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
import dynet_config
dynet_config.set(random_seed=42, mem=512, autobatch=False, requested_gpus=0)
from max_sub_tree.mstlstm_empty import MaxSubTreeWithEmptyParser
op = {
"epochs": 20,
"lstmdims": 150,
"lstmlayers": 2,
"activation": "relu",
"pembedding": 50,
}
home = os.path.expanduser("~")
outdir_prefix = f"{home}/Development/nullnode/20180203/"
data_dir = f"{home}/Development/large-data/emptynode-data/"
trainer = MaxSubTreeWithEmptyParser.get_training_scheduler()
extrn = {
"en": data_dir + "../sskip.100.vectors",
"cn": data_dir + "../sample.win7.vector"
}
import random
import dynet as dy
import dynet_config
from syn.model.build.treelstm.vectorizer.Vectorizer import get_vectorized_issue
from syn.model.build.treelstm.models import Classifier, TreeLstm
MEMORIA_ASIGNADA = 12000
dynet_config.set(mem=MEMORIA_ASIGNADA, requested_gpus=1, autobatch=True)
dynet_config.set_gpu()
def train_model(net, model_name, max_sentence_length, data):
print("Tamaño máximo de la sentencia: " + str(max_sentence_length))
_data_train = [(l, s1, s2, ls1, ls2) for _, l, s1, s2, ls1, ls2 in data[0]
if len(ls1) <= max_sentence_length and len(ls1) > 1
and len(ls2) <= max_sentence_length and len(ls2) > 1]
_data_test = [(l, s1, s2, ls1, ls2) for _, l, s1, s2, ls1, ls2 in data[1]
if len(ls1) <= max_sentence_length and len(ls1) > 1
and len(ls2) <= max_sentence_length and len(ls2) > 1]
l = list(_data_train)
random.shuffle(l)
_data_train = tuple(l)
l = list(_data_test)
random.shuffle(l)
_data_test = tuple(l)
num_batches = len(_data_train)
print("El conjunto de datos de entrenamiento contiene " +
dest='model_tagging',
help='precomputed tagging model')
parser.add_option('--model-parsing',
action='store',
dest='model_parsing',
help='precomputed parsing model')
(params, _) = parser.parse_args(sys.argv)
memory = int(params.memory)
if params.autobatch:
autobatch = True
else:
autobatch = False
dynet_config.set(mem=memory,
random_seed=9,
autobatch=autobatch,
weight_decay=params.decay)
if params.gpu:
dynet_config.set_gpu()
from io_utils.conll import Dataset
from io_utils.mt import MTDataset
from io_utils.config import TokenizerConfig
from io_utils.config import TaggerConfig
from io_utils.config import ParserConfig
from io_utils.config import LemmatizerConfig
from io_utils.config import NMTConfig
from io_utils.config import TieredTokenizerConfig
from io_utils.config import CompoundWordConfig
from io_utils.embeddings import WordEmbeddings
from io_utils.encodings import Encodings
from __future__ import print_function
import dynet_config
dynet_config.set(mem=1024, random_seed=123456789)
import dynet as dy
import numpy as np
import sys
from utils import FORM, XPOS, DEPREL
from utils import create_dictionary, create_index, read_conllu, map_to_instances, shuffled_stream
from utils import parse_projective
from layers import Embeddings, BiLSTM
import random
class MLP(object):
pass
if __name__ == "__main__":
random.seed(1)
train_file = "../treebanks/train/en/en.conllu"
index = create_index(create_dictionary(read_conllu(train_file)))
train_data = list(
map_to_instances(read_conllu(train_file), index, (FORM, XPOS)))
max_epochs = 30
lstm_dim = 250
arc_hidden_dim = 100
label_hidden_dim = 100
pc = dy.ParameterCollection()
from __future__ import print_function
import argparse
import collections
import random
import sys
import dynet_config
dynet_config.set(mem="5120,5120,1,512", profiling=0)
dynet_config.set_gpu()
#dynet_config.set(mem=512,profiling=1)
#dynet_config.set(mem=32.0*1024)
import dynet as dy
import numpy as np
sys.path.append('/home/austinma/git/rnnlm/')
sys.path.append('../')
from utils import Vocabulary
from utils import MLP
import harness
ParserState = collections.namedtuple('ParserState', 'open_constits, spine')
class TopDownDepLM:
def __init__(self, pc, vocab, layers, state_dim, final_hidden_dim, tied,
residual):
self.vocab = vocab
self.layers = layers
self.state_dim = state_dim
self.tied = tied
self.residual = residual
def main():
# Configuration file processing
argparser = argparse.ArgumentParser()
argparser.add_argument('--config_file', default='../configs/debug.cfg')
argparser.add_argument('--continue_training',
action='store_true',
help='Load model Continue Training')
argparser.add_argument('--name',
default='experiment',
help='The name of the experiment.')
argparser.add_argument('--model',
default='s2s',
help='s2s: seq2seq-head-selection-model'
's2tBFS: seq2tree-BFS-decoder-model'
's2tDFS: seq2tree-DFS-decoder-model')
argparser.add_argument('--gpu', default='0', help='GPU ID (-1 to cpu)')
args, extra_args = argparser.parse_known_args()
cfg = IniConfigurator(args.config_file, extra_args)
# Logger setting
logger = dual_channel_logger(
__name__,
file_path=cfg.LOG_FILE,
file_model='w',
formatter='%(asctime)s - %(levelname)s - %(message)s',
time_formatter='%m-%d %H:%M')
from eval.script_evaluator import ScriptEvaluator
# DyNet setting
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
import dynet_config
dynet_config.set(mem=cfg.DYNET_MEM, random_seed=cfg.DYNET_SEED)
dynet_config.set_gpu()
import dynet as dy
from models.token_representation import TokenRepresentation
from antu.nn.dynet.seq2seq_encoders import DeepBiRNNBuilder, orthonormal_VanillaLSTMBuilder
from models.graph_nn_decoder import GraphNNDecoder
# Build the dataset of the training process
# Build data reader
data_reader = PTBReader(
field_list=['word', 'tag', 'head', 'rel'],
root='0\t**root**\t_\t**rcpos**\t**rpos**\t_\t0\t**rrel**\t_\t_',
spacer=r'[\t]',
)
# Build vocabulary with pretrained glove
vocabulary = Vocabulary()
g_word, _ = glove_reader(cfg.GLOVE)
pretrained_vocabs = {'glove': g_word}
vocabulary.extend_from_pretrained_vocab(pretrained_vocabs)
# Setup datasets
datasets_settings = {
'train': DatasetSetting(cfg.TRAIN, True),
'dev': DatasetSetting(cfg.DEV, False),
'test': DatasetSetting(cfg.TEST, False),
}
datasets = PTBDataset(vocabulary, datasets_settings, data_reader)
counters = {'word': Counter(), 'tag': Counter(), 'rel': Counter()}
datasets.build_dataset(counters,
no_pad_namespace={'rel'},
no_unk_namespace={'rel'})
# Build model
# Parameter
pc = dy.ParameterCollection()
trainer = dy.AdamTrainer(pc,
alpha=cfg.LR,
beta_1=cfg.ADAM_BETA1,
beta_2=cfg.ADAM_BETA2,
eps=cfg.EPS)
# Token Representation Layer
token_repre = TokenRepresentation(pc, cfg, datasets.vocabulary)
# BiLSTM Encoder Layer
encoder = DeepBiRNNBuilder(pc, cfg.ENC_LAYERS, token_repre.token_dim,
cfg.ENC_H_DIM, orthonormal_VanillaLSTMBuilder)
# GNN Decoder Layer
decoder = GraphNNDecoder(pc, cfg, datasets.vocabulary)
# PTB Evaluator
my_eval = ScriptEvaluator(['Valid', 'Test'], datasets.vocabulary)
# Build Training Batch
def cmp(ins):
return len(ins['word'])
train_batch = datasets.get_batches('train', cfg.TRAIN_BATCH_SIZE, True,
cmp, True)
valid_batch = list(
datasets.get_batches('dev', cfg.TEST_BATCH_SIZE, False, cmp, False))
test_batch = list(
datasets.get_batches('test', cfg.TEST_BATCH_SIZE, False, cmp, False))
# Train model
BEST_DEV_LAS = BEST_DEV_UAS = BEST_ITER = cnt_iter = 0
valid_loss = [[] for i in range(cfg.GRAPH_LAYERS + 3)]
logger.info("Experiment name: %s" % args.name)
SHA = os.popen('git log -1 | head -n 1 | cut -c 8-13').readline().rstrip()
logger.info('Git SHA: %s' % SHA)
while cnt_iter < cfg.MAX_ITER:
dy.renew_cg()
cnt_iter += 1
indexes, masks, truth = train_batch.__next__()
vectors = token_repre(indexes, True)
vectors = encoder(vectors, None, cfg.RNN_DROP, cfg.RNN_DROP,
np.array(masks['1D']).T, True)
loss, part_loss = decoder(vectors, masks, truth, True, True)
for i, l in enumerate([loss] + part_loss):
valid_loss[i].append(l.value())
loss.backward()
trainer.learning_rate = cfg.LR * cfg.LR_DECAY**(cnt_iter /
cfg.LR_ANNEAL)
trainer.update()
if cnt_iter % cfg.VALID_ITER:
continue
# Validation
for i in range(len(valid_loss)):
valid_loss[i] = str(round(np.mean(valid_loss[i]), 2))
avg_loss = ', '.join(valid_loss)
logger.info("")
logger.info("Iter: %d-%d, Avg_loss: %s, LR (%f), Best (%d)" %
(cnt_iter / cfg.VALID_ITER, cnt_iter, avg_loss,
trainer.learning_rate, BEST_ITER))
valid_loss = [[] for i in range(cfg.GRAPH_LAYERS + 3)]
my_eval.clear('Valid')
for indexes, masks, truth in valid_batch:
dy.renew_cg()
vectors = token_repre(indexes, False)
vectors = encoder(vectors, None, cfg.RNN_DROP, cfg.RNN_DROP,
np.array(masks['1D']).T, False)
pred = decoder(vectors, masks, None, False, True)
my_eval.add_truth('Valid', truth)
my_eval.add_pred('Valid', pred)
dy.save(cfg.LAST_FILE, [token_repre, encoder, decoder])
if my_eval.evaluation('Valid', cfg.PRED_DEV, cfg.DEV):
BEST_ITER = cnt_iter / cfg.VALID_ITER
os.system('cp %s.data %s.data' % (cfg.LAST_FILE, cfg.BEST_FILE))
os.system('cp %s.meta %s.meta' % (cfg.LAST_FILE, cfg.BEST_FILE))
# Just record test result
my_eval.clear('Test')
for indexes, masks, truth in test_batch:
dy.renew_cg()
vectors = token_repre(indexes, False)
vectors = encoder(vectors, None, cfg.RNN_DROP, cfg.RNN_DROP,
np.array(masks['1D']).T, False)
pred = decoder(vectors, masks, None, False, True)
my_eval.add_truth('Test', truth)
my_eval.add_pred('Test', pred)
my_eval.evaluation('Test', cfg.PRED_TEST, cfg.TEST)
my_eval.print_best_result('Valid')
test_pc = dy.ParameterCollection()
token_repre, encoder, decoder = dy.load(cfg.BEST_FILE, test_pc)
my_eval.clear('Test')
test_batch = datasets.get_batches('test', cfg.TEST_BATCH_SIZE, False, cmp,
False)
for indexes, masks, truth in test_batch:
dy.renew_cg()
vectors = token_repre(indexes, False)
vectors = encoder(vectors, None, cfg.RNN_DROP, cfg.RNN_DROP,
np.array(masks['1D']).T, False)
pred = decoder(vectors, masks, None, False, True)
my_eval.add_truth('Test', truth)
my_eval.add_pred('Test', pred)
my_eval.evaluation('Test', cfg.PRED_TEST, cfg.TEST)
import networkx as nx
import random
import numpy as np
import dynet_config
#dynet_config.set_gpu()
dynet_config.set(mem=3200)
import dynet as dy
numberOfGraphs = 186
graphs = {}
for number in range(0, numberOfGraphs):
#nacitavam graf
md = nx.read_gml('./graphs/graph' + str(number) + '.gml')
#vytvorim si prepene ktore pak pouzivam
# sloncik vstupov jednotlivych nodov
inputs = {}
#mapovanie na nazvy nodov
mapping_names = {}
#mapovanie na cisla
mapping_numbers = {}
i = 0
#vytvorenie mapovania
for name, id in enumerate(md.nodes()):
#rozdelenie a zobratie mena z labelu
nm = id.split("\n")[0]
#mapujem mena na cele popisy
mapping_names[id] = nm
#mapujem cisla na mena
mapping_numbers[nm] = i
parser.add_option("--set-mem", action='store', dest='memory', default='2048', type='int',
help='preallocate memory for batch training (default 2048)')
parser.add_option("--use-gpu", action='store_true', dest='gpu',
help='turn on/off GPU support')
parser.add_option("--sample", action='store_true', dest='sample',
help='Use random sampling')
parser.add_option('--mgc-order', action='store', dest='mgc_order', type='int',
help='Order of MGC parameters (default=80)', default=80)
parser.add_option('--temperature', action='store', dest='temperature', type='float',
help='Exploration parameter (max 1.0, default 0.8)', default=0.8)
parser.add_option('--target-sample-rate', action='store', dest='target_sample_rate',
help='Resample input files at this rate (default=24000)', type='int', default=24000)
(params, _) = parser.parse_args(sys.argv)
if not params.speaker:
print("Speaker identity is mandatory")
elif not params.txt_file:
print("Input file is mandatory")
elif not params.output_file:
print("Output file is mandatory")
memory = int(params.memory)
# for compatibility we have to add this paramater
params.learning_rate = 0.0001
dynet_config.set(mem=memory, random_seed=9)
if params.gpu:
dynet_config.set_gpu()
synthesize(params.speaker, params.txt_file, params.output_file, params)
import os, sys, re
import numpy
import csv
import pickle
from tqdm import tqdm
from pprint import pprint
from sklearn.metrics import log_loss
import dynet_config
dynet_config.set(
mem=4096, # can probably get away with 1024
autobatch=True, # utilize autobatching
random_seed=1978 # simply for reproducibility here
)
import dynet
# 0 vs 1
def load(f = 'mnist_train.csv'):
x_py = []
y_py = []
with open(f) as rf:
reader = csv.reader(rf, delimiter = ',')
for line in tqdm(reader):
y_onehot = [0 for _ in range(10)]
y_onehot[int(line[0])] = 1
y_py.append(y_onehot)
x_py.append(line[1:])
return numpy.asarray(x_py, dtype = 'int8'), numpy.asarray(y_py, dtype = 'int8')
dest='model_base',
help='Location where to store the model')
parser.add_option("--patience",
action='store',
dest='patience',
default='20',
type='int',
help='Early stopping condition')
(params, _) = parser.parse_args(sys.argv)
memory = int(params.memory)
if params.autobatch:
autobatch = True
else:
autobatch = False
dynet_config.set(mem=memory, random_seed=9, autobatch=autobatch)
if params.gpu:
dynet_config.set_gpu()
import dynet as dy
if params.train:
train(params)
elif params.test:
test(params)
elif params.convert:
convert(params)
else:
print("Invalid parameters. Use '--help' for help")
import random
import dynet_config
import os, sys
print(os.environ)
print(sys.path)
os.environ['DYNET_RANDOM_SEED'] = str(random.randrange(10000000))
dynet_config.set(random_seed=int(os.environ['DYNET_RANDOM_SEED']))
import dynet
from run import most_frequent_baseline, lstm_mlp_baseline, dataset_statistics
from collections import Counter
from datasets.streusle_v4 import streusle
# streusle_loader = streusle.StreusleLoader()
# train_records, dev_records, test_records = streusle_loader.load()
# print('loaded %d train records with %d tokens (%d unique), %d prepositions' % (len(train_records),
# sum([len(x.tagged_tokens) for x in train_records]),
# len(set([t.token for s in train_records for t in s.tagged_tokens])),
# len([tok for rec in train_records for tok in rec.tagged_tokens if tok.supersense_combined])))
# print('loaded %d dev records with %d tokens (%d unique), %d prepositions' % (len(dev_records),
# sum([len(x.tagged_tokens) for x in dev_records]),
# len(set([t.token for s in dev_records for t in s.tagged_tokens])),
# len([tok for rec in dev_records for tok in rec.tagged_tokens if tok.supersense_combined])))
# print('loaded %d test records with %d tokens (%d unique), %d prepositions' % (len(test_records),
# sum([len(x.tagged_tokens) for x in test_records]),
# len(set([t.token for s in test_records for t in s.tagged_tokens])),
# len([tok for rec in test_records for tok in rec.tagged_tokens if tok.supersense_combined])))
#
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import random
import sys
import dynet_config
dynet_config.set(mem=8 * 1024)
dynet_config.set_gpu()
import dynet as dy
sys.path.append('/home/austinma/git/rnnlm/')
sys.path.append('..')
from utils import Vocabulary
from utils import read_corpus
from utils import MLP
import harness
class RNNLM:
def __init__(self, pc, layers, emb_dim, hidden_dim, vocab_size, tied):
self.spec = (layers, emb_dim, hidden_dim, vocab_size)
self.pc = pc.add_subcollection()
self.rnn = dy.LSTMBuilder(layers, emb_dim, hidden_dim, self.pc)
self.initial_state_params = [
self.pc.add_parameters((hidden_dim, )) for _ in range(2 * layers)
]
self.output_mlp = MLP(self.pc, [hidden_dim, hidden_dim, vocab_size])
import random
import numpy as np
from collections import Counter, defaultdict
from itertools import count
import dynet_config
dynet_config.set(mem=1024, random_seed=42)
random.seed(42)
import dynet as dy
class Vocab:
def __init__(self, w2i=None):
if w2i is None: w2i = defaultdict(count(0).__next__)
self.w2i = dict(w2i)
self.i2w = {i: w for w, i in w2i.items()}
@classmethod
def from_corpus(cls, corpus):
w2i = defaultdict(count(0).__next__)
for sentence in corpus:
[w2i[word] for word in sentence]
return Vocab(w2i)
def size(self):
return len(self.w2i.keys())
class Dimensions:
def __init__(self):
self.hidden = 32
import os
os.environ['XNMT_SETTINGS'] = 'unittest'
if os.environ.get('XNMT_BACKEND', "dynet") == 'dynet':
import dynet_config
dynet_config.set(random_seed=2)
import dynet_config
dynet_config.set(mem=2048, random_seed=9)
import dynet as dy
import numpy as np
class RunTimeEncoder:
def __init__(self):
self.model = dy.Model()
self.phone_lookup = self.model.add_lookup_parameters((42, 100))
self.feature_lookup = self.model.add_lookup_parameters((3, 100))
self.speaker_lookup = self.model.add_lookup_parameters((18, 200))
self.encoder_fw = dy.VanillaLSTMBuilder(1, 100, 256, self.model)
self.encoder_bw = dy.VanillaLSTMBuilder(1, 100, 256, self.model)
self.decoder = dy.VanillaLSTMBuilder(2, 812, 1024, self.model)
self.hid_w = self.model.add_parameters((500, 1024))
self.hid_b = self.model.add_parameters((500, ))
self.proj_w_1 = self.model.add_parameters((80, 500))
self.proj_b_1 = self.model.add_parameters((80, ))
self.proj_w_2 = self.model.add_parameters((80, 500))
self.proj_b_2 = self.model.add_parameters((80, ))
self.proj_w_3 = self.model.add_parameters((80, 500))
self.proj_b_3 = self.model.add_parameters((80, ))
