def setUp(self):
# Seeding
numpy.random.seed(2)
random.seed(2)
layer_dim = 64
xnmt.events.clear()
ParamManager.init_param_col()
self.segment_encoder_bilstm = BiLSTMSeqTransducer(input_dim=layer_dim, hidden_dim=layer_dim)
self.segment_composer = SumComposer()
self.src_reader = CharFromWordTextReader(vocab=Vocab(vocab_file="examples/data/head.ja.charvocab"))
self.trg_reader = PlainTextReader(vocab=Vocab(vocab_file="examples/data/head.en.vocab"))
self.loss_calculator = FeedbackLoss(child_loss=MLELoss(), repeat=5)
baseline = Linear(input_dim=layer_dim, output_dim=1)
policy_network = Linear(input_dim=layer_dim, output_dim=2)
self.poisson_prior = PoissonPrior(mu=3.3)
self.eps_greedy = EpsilonGreedy(eps_prob=0.0, prior=self.poisson_prior)
self.conf_penalty = ConfidencePenalty()
self.policy_gradient = PolicyGradient(input_dim=layer_dim,
output_dim=2,
baseline=baseline,
policy_network=policy_network,
z_normalization=True,
conf_penalty=self.conf_penalty)
self.length_prior = PoissonLengthPrior(lmbd=3.3, weight=1)
self.segmenting_encoder = SegmentingSeqTransducer(
embed_encoder = self.segment_encoder_bilstm,
segment_composer = self.segment_composer,
final_transducer = BiLSTMSeqTransducer(input_dim=layer_dim, hidden_dim=layer_dim),
policy_learning = self.policy_gradient,
eps_greedy = self.eps_greedy,
length_prior = self.length_prior,
)
self.model = DefaultTranslator(
src_reader=self.src_reader,
trg_reader=self.trg_reader,
src_embedder=SimpleWordEmbedder(emb_dim=layer_dim, vocab_size=100),
encoder=self.segmenting_encoder,
attender=MlpAttender(input_dim=layer_dim, state_dim=layer_dim, hidden_dim=layer_dim),
trg_embedder=SimpleWordEmbedder(emb_dim=layer_dim, vocab_size=100),
decoder=AutoRegressiveDecoder(input_dim=layer_dim,
rnn=UniLSTMSeqTransducer(input_dim=layer_dim, hidden_dim=layer_dim,
decoder_input_dim=layer_dim, yaml_path="decoder"),
transform=AuxNonLinear(input_dim=layer_dim, output_dim=layer_dim,
aux_input_dim=layer_dim),
scorer=Softmax(vocab_size=100, input_dim=layer_dim),
trg_embed_dim=layer_dim,
bridge=CopyBridge(dec_dim=layer_dim, dec_layers=1)),
)
event_trigger.set_train(True)
self.layer_dim = layer_dim
self.src_data = list(self.model.src_reader.read_sents("examples/data/head.ja"))
self.trg_data = list(self.model.trg_reader.read_sents("examples/data/head.en"))
my_batcher = batchers.TrgBatcher(batch_size=3)
self.src, self.trg = my_batcher.pack(self.src_data, self.trg_data)
dy.renew_cg(immediate_compute=True, check_validity=True)
def __init__(self,
word_vocab=None,
embedding=None,
ngram_size=4,
vocab_size=32000,
cache_id_pool=None,
cache_word_table=None,
char_vocab=Ref(Path("model.src_reader.vocab")),
hidden_dim=Ref("exp_global.default_layer_dim"),
param_init=Ref("exp_global.param_init", default=bare(GlorotInitializer)),
bias_init=Ref("exp_global.bias_init", default=bare(ZeroInitializer))):
super().__init__(word_vocab, vocab_size, cache_id_pool, cache_word_table)
# Attributes
if word_vocab is None:
self.dict_entry = vocab_size+1
else:
self.dict_entry = len(word_vocab)
self.char_vocab = char_vocab
self.param_init = param_init
self.bias_init = bias_init
self.hidden_dim = hidden_dim
self.word_vect = None
# Word Embedding
self.ngram_size = ngram_size
self.embedding = self.add_serializable_component("embedding", embedding,
lambda: Linear(input_dim=self.dict_entry,
output_dim=hidden_dim,
param_init=param_init,
bias_init=bias_init))
def __init__(self, dy_model, input_dim, output_dim):
self.L = Linear(input_dim,
output_dim,
dy_model,
bias=False,
param_init=LeCunUniformInitializer(),
bias_init=LeCunUniformInitializer())
self.output_dim = output_dim
def __init__(self,
composers,
hidden_dim=Ref("exp_global.default_layer_dim"),
embedding=None,
param_init=Ref("exp_global.param_init", default=bare(GlorotInitializer)),
bias_init=Ref("exp_global.bias_init", default=bare(ZeroInitializer))):
super().__init__()
assert len(composers) > 1
self.composers = composers
self.embedding = self.add_serializable_component("embedding", embedding,
lambda: Linear(input_dim=len(composers)*hidden_dim,
output_dim=hidden_dim,
param_init=param_init,
bias_init=bias_init))
def __init__(self,
baseline=None,
evaluation_metric:metrics.SentenceLevelEvaluator = bare(metrics.FastBLEUEvaluator),
search_strategy:SearchStrategy = bare(SamplingSearch),
sample_length:int = 50,
use_baseline:bool = False,
inv_eval:bool = True,
decoder_hidden_dim:int = Ref("exp_global.default_layer_dim")):
self.inv_eval = inv_eval
self.search_strategy = search_strategy
self.evaluation_metric = evaluation_metric
if use_baseline:
self.baseline = self.add_serializable_component("baseline", baseline,
lambda: Linear(input_dim=decoder_hidden_dim, output_dim=1))
else:
self.baseline = None
def __init__(self,
word_vocab=None,
ngram_size=4,
src_vocab=Ref(Path("model.src_reader.vocab")),
hidden_dim=Ref("exp_global.default_layer_dim"),
word_ngram=None,
vocab_size=None):
super().__init__()
if word_vocab is None:
word_vocab = Vocab()
dict_entry = vocab_size
else:
dict_entry = len(word_vocab)
self.dict_entry = dict_entry
self.src_vocab = src_vocab
self.word_vocab = word_vocab
self.ngram_size = ngram_size
self.word_ngram = self.add_serializable_component("word_ngram", word_ngram,
lambda: Linear(input_dim=dict_entry,
output_dim=hidden_dim))