1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
|
"""
Utility functions.
"""
import argparse
from collections import Counter
from contextlib import contextmanager
import gzip
import json
import logging
import lzma
import os
import random
import sys
import unicodedata
import zipfile
import torch
import numpy as np
from stanza.models.common.constant import lcode2lang
import stanza.models.common.seq2seq_constant as constant
import stanza.utils.conll18_ud_eval as ud_eval
logger = logging.getLogger('stanza')
# filenames
def get_wordvec_file(wordvec_dir, shorthand, wordvec_type=None):
""" Lookup the name of the word vectors file, given a directory and the language shorthand.
"""
lcode, tcode = shorthand.split('_', 1)
lang = lcode2lang[lcode]
# locate language folder
word2vec_dir = os.path.join(wordvec_dir, 'word2vec', lang)
fasttext_dir = os.path.join(wordvec_dir, 'fasttext', lang)
lang_dir = None
if wordvec_type is not None:
lang_dir = os.path.join(wordvec_dir, wordvec_type, lang)
if not os.path.exists(lang_dir):
raise FileNotFoundError("Word vector type {} was specified, but directory {} does not exist".format(wordvec_type, lang_dir))
elif os.path.exists(word2vec_dir): # first try word2vec
lang_dir = word2vec_dir
elif os.path.exists(fasttext_dir): # otherwise try fasttext
lang_dir = fasttext_dir
else:
raise FileNotFoundError("Cannot locate word vector directory for language: {} Looked in {} and {}".format(lang, word2vec_dir, fasttext_dir))
# look for wordvec filename in {lang_dir}
filename = os.path.join(lang_dir, '{}.vectors'.format(lcode))
if os.path.exists(filename + ".xz"):
filename = filename + ".xz"
elif os.path.exists(filename + ".txt"):
filename = filename + ".txt"
return filename
@contextmanager
def open_read_text(filename, encoding="utf-8"):
"""
Opens a file as an .xz file or .gz if it ends with .xz or .gz, or regular text otherwise.
Use as a context
eg:
with open_read_text(filename) as fin:
do stuff
File will be closed once the context exits
"""
if filename.endswith(".xz"):
with lzma.open(filename, mode='rt', encoding=encoding) as fin:
yield fin
elif filename.endswith(".gz"):
with gzip.open(filename, mode='rt', encoding=encoding) as fin:
yield fin
else:
with open(filename, encoding=encoding) as fin:
yield fin
@contextmanager
def open_read_binary(filename):
"""
Opens a file as an .xz file or .gz if it ends with .xz or .gz, or regular binary file otherwise.
If a .zip file is given, it can be read if there is a single file in there
Use as a context
eg:
with open_read_binary(filename) as fin:
do stuff
File will be closed once the context exits
"""
if filename.endswith(".xz"):
with lzma.open(filename, mode='rb') as fin:
yield fin
elif filename.endswith(".gz"):
with gzip.open(filename, mode='rb') as fin:
yield fin
elif filename.endswith(".zip"):
with zipfile.ZipFile(filename) as zin:
input_names = zin.namelist()
if len(input_names) == 0:
raise ValueError("Empty zip archive")
if len(input_names) > 1:
raise ValueError("zip file %s has more than one file in it")
with zin.open(input_names[0]) as fin:
yield fin
else:
with open(filename, mode='rb') as fin:
yield fin
# training schedule
def get_adaptive_eval_interval(cur_dev_size, thres_dev_size, base_interval):
""" Adjust the evaluation interval adaptively.
If cur_dev_size <= thres_dev_size, return base_interval;
else, linearly increase the interval (round to integer times of base interval).
"""
if cur_dev_size <= thres_dev_size:
return base_interval
else:
alpha = round(cur_dev_size / thres_dev_size)
return base_interval * alpha
# ud utils
def ud_scores(gold_conllu_file, system_conllu_file):
gold_ud = ud_eval.load_conllu_file(gold_conllu_file)
system_ud = ud_eval.load_conllu_file(system_conllu_file)
evaluation = ud_eval.evaluate(gold_ud, system_ud)
return evaluation
def harmonic_mean(a, weights=None):
if any([x == 0 for x in a]):
return 0
else:
assert weights is None or len(weights) == len(a), 'Weights has length {} which is different from that of the array ({}).'.format(len(weights), len(a))
if weights is None:
return len(a) / sum([1/x for x in a])
else:
return sum(weights) / sum(w/x for x, w in zip(a, weights))
# torch utils
def get_optimizer(name, parameters, lr, betas=(0.9, 0.999), eps=1e-8, momentum=0):
if name == 'sgd':
return torch.optim.SGD(parameters, lr=lr, momentum=momentum)
elif name == 'adagrad':
return torch.optim.Adagrad(parameters, lr=lr)
elif name == 'adam':
return torch.optim.Adam(parameters, lr=lr, betas=betas, eps=eps)
elif name == 'adamax':
return torch.optim.Adamax(parameters) # use default lr
else:
raise Exception("Unsupported optimizer: {}".format(name))
def change_lr(optimizer, new_lr):
for param_group in optimizer.param_groups:
param_group['lr'] = new_lr
def flatten_indices(seq_lens, width):
flat = []
for i, l in enumerate(seq_lens):
for j in range(l):
flat.append(i * width + j)
return flat
def keep_partial_grad(grad, topk):
"""
Keep only the topk rows of grads.
"""
assert topk < grad.size(0)
grad.data[topk:].zero_()
return grad
# other utils
def ensure_dir(d, verbose=True):
if not os.path.exists(d):
if verbose:
logger.info("Directory {} does not exist; creating...".format(d))
# exist_ok: guard against race conditions
os.makedirs(d, exist_ok=True)
def save_config(config, path, verbose=True):
with open(path, 'w') as outfile:
json.dump(config, outfile, indent=2)
if verbose:
print("Config saved to file {}".format(path))
return config
def load_config(path, verbose=True):
with open(path) as f:
config = json.load(f)
if verbose:
print("Config loaded from file {}".format(path))
return config
def print_config(config):
info = "Running with the following configs:\n"
for k,v in config.items():
info += "\t{} : {}\n".format(k, str(v))
logger.info("\n" + info + "\n")
def normalize_text(text):
return unicodedata.normalize('NFD', text)
def unmap_with_copy(indices, src_tokens, vocab):
"""
Unmap a list of list of indices, by optionally copying from src_tokens.
"""
result = []
for ind, tokens in zip(indices, src_tokens):
words = []
for idx in ind:
if idx >= 0:
words.append(vocab.id2word[idx])
else:
idx = -idx - 1 # flip and minus 1
words.append(tokens[idx])
result += [words]
return result
def prune_decoded_seqs(seqs):
"""
Prune decoded sequences after EOS token.
"""
out = []
for s in seqs:
if constant.EOS in s:
idx = s.index(constant.EOS_TOKEN)
out += [s[:idx]]
else:
out += [s]
return out
def prune_hyp(hyp):
"""
Prune a decoded hypothesis
"""
if constant.EOS_ID in hyp:
idx = hyp.index(constant.EOS_ID)
return hyp[:idx]
else:
return hyp
def prune(data_list, lens):
assert len(data_list) == len(lens)
nl = []
for d, l in zip(data_list, lens):
nl.append(d[:l])
return nl
def sort(packed, ref, reverse=True):
"""
Sort a series of packed list, according to a ref list.
Also return the original index before the sort.
"""
assert (isinstance(packed, tuple) or isinstance(packed, list)) and isinstance(ref, list)
packed = [ref] + [range(len(ref))] + list(packed)
sorted_packed = [list(t) for t in zip(*sorted(zip(*packed), reverse=reverse))]
return tuple(sorted_packed[1:])
def unsort(sorted_list, oidx):
"""
Unsort a sorted list, based on the original idx.
"""
assert len(sorted_list) == len(oidx), "Number of list elements must match with original indices."
if len(sorted_list) == 0:
return []
_, unsorted = [list(t) for t in zip(*sorted(zip(oidx, sorted_list)))]
return unsorted
def sort_with_indices(data, key=None, reverse=False):
"""
Sort data and return both the data and the original indices.
One useful application is to sort by length, which can be done with key=len
Returns the data as a sorted list, then the indices of the original list.
"""
if not data:
return [], []
if key:
ordered = sorted(enumerate(data), key=lambda x: key(x[1]), reverse=reverse)
else:
ordered = sorted(enumerate(data), key=lambda x: x[1], reverse=reverse)
result = tuple(zip(*ordered))
return result[1], result[0]
def split_into_batches(data, batch_size):
"""
Returns a list of intervals so that each interval is either <= batch_size or one element long.
Long elements are not dropped from the intervals.
data is a list of lists
batch_size is how long to make each batch
return value is a list of pairs, start_idx end_idx
"""
intervals = []
interval_start = 0
interval_size = 0
for idx, line in enumerate(data):
if len(line) > batch_size:
# guess we'll just hope the model can handle a batch of this size after all
if interval_size > 0:
intervals.append((interval_start, idx))
intervals.append((idx, idx+1))
interval_start = idx+1
interval_size = 0
elif len(line) + interval_size > batch_size:
# this line puts us over batch_size
intervals.append((interval_start, idx))
interval_start = idx
interval_size = len(line)
else:
interval_size = interval_size + len(line)
if interval_size > 0:
# there's some leftover
intervals.append((interval_start, len(data)))
return intervals
def tensor_unsort(sorted_tensor, oidx):
"""
Unsort a sorted tensor on its 0-th dimension, based on the original idx.
"""
assert sorted_tensor.size(0) == len(oidx), "Number of list elements must match with original indices."
backidx = [x[0] for x in sorted(enumerate(oidx), key=lambda x: x[1])]
return sorted_tensor[backidx]
def set_random_seed(seed, cuda):
"""
Set a random seed on all of the things which might need it.
torch, np, python random, and torch.cuda
"""
if seed is None:
seed = random.randint(0, 1000000000)
torch.manual_seed(seed)
np.random.seed(seed)
random.seed(seed)
if cuda:
torch.cuda.manual_seed(seed)
return seed
def get_known_tags(known_tags):
"""
Turns either a list or a list of lists into a single sorted list
Actually this is not at all necessarily about tags
"""
if isinstance(known_tags, list) and isinstance(known_tags[0], list):
known_tags = sorted(set(x for y in known_tags for x in y))
else:
known_tags = sorted(known_tags)
return known_tags
def find_missing_tags(known_tags, test_tags):
if isinstance(known_tags, list) and isinstance(known_tags[0], list):
known_tags = set(x for y in known_tags for x in y)
if isinstance(test_tags, list) and isinstance(test_tags[0], list):
test_tags = sorted(set(x for y in test_tags for x in y))
missing_tags = sorted(x for x in test_tags if x not in known_tags)
return missing_tags
def warn_missing_tags(known_tags, test_tags, test_set_name):
"""
Print a warning if any tags present in the second list are not in the first list.
Can also handle a list of lists.
"""
missing_tags = find_missing_tags(known_tags, test_tags)
if len(missing_tags) > 0:
logger.warning("Found tags in {} missing from the expected tag set: {}".format(test_set_name, missing_tags))
return True
return False
def get_tqdm():
"""
Return a tqdm appropriate for the situation
imports tqdm depending on if we're at a console, redir to a file, notebook, etc
from @tcrimi at https://github.com/tqdm/tqdm/issues/506
This replaces `import tqdm`, so for example, you do this:
tqdm = utils.get_tqdm()
then do this when you want a scroll bar or regular iterator depending on context:
tqdm(list)
If there is no tty, the returned tqdm will always be disabled
unless disable=False is specifically set.
"""
try:
ipy_str = str(type(get_ipython()))
if 'zmqshell' in ipy_str:
from tqdm import tqdm_notebook as tqdm
return tqdm
if 'terminal' in ipy_str:
from tqdm import tqdm
return tqdm
except:
if sys.stderr.isatty():
from tqdm import tqdm
return tqdm
from tqdm import tqdm
def hidden_tqdm(*args, **kwargs):
if "disable" in kwargs:
return tqdm(*args, **kwargs)
kwargs["disable"] = True
return tqdm(*args, **kwargs)
return hidden_tqdm
def checkpoint_name(save_dir, save_name, checkpoint_name):
"""
Will return a recommended checkpoint name for the given dir, save_name, optional checkpoint_name
For example, can pass in args['save_dir'], args['save_name'], args['checkpoint_save_name']
"""
if checkpoint_name:
return os.path.join(save_dir, checkpoint_name)
save_name = os.path.join(save_dir, save_name)
if save_name.endswith(".pt"):
return save_name[:-3] + "_checkpoint.pt"
return save_name + "_checkpoint"
def load_elmo(elmo_model):
# This import is here so that Elmo integration can be treated
# as an optional feature
import elmoformanylangs
logger.info("Loading elmo: %s" % elmo_model)
elmo_model = elmoformanylangs.Embedder(elmo_model)
return elmo_model
def log_training_args(args, args_logger):
"""
For record keeping purposes, log the arguments when training
"""
if isinstance(args, argparse.Namespace):
args = vars(args)
keys = sorted(args.keys())
log_lines = ['%s: %s' % (k, args[k]) for k in keys]
args_logger.info('ARGS USED AT TRAINING TIME:\n%s\n', '\n'.join(log_lines))
|