Datasets:

danidarko

/

docs

like 0

return re.sub('\\W', '_', task_name)

def get_latest_filename(filenames: List[str]) -> str:

return max(filenames, key=lambda f: get_file_datetime(f))

def get_results_filenames(filenames: List[str]) -> List[str]:

return [f for f in filenames if '/results_' in f and '.json' in f]

def get_sample_results_filenames(filenames: List[str]) -> List[str]:

return [f for f in filenames if '/samples_' in f and '.json' in f]

def get_rolling_token_windows(token_list, prefix_token, max_seq_len, context_len):

assert 1 <= context_len <= max_seq_len

if not token_list:

return

pred_len = max_seq_len - context_len + 1

predicted = 0

first_seq_len = min(max_seq_len, len(token_list))

yield ([prefix_token] + token_list[:first_seq_len - 1], token_list[:first_seq_len])

predicted += first_seq_len

while predicted < len(token_list):

window_pred_len = min(len(token_list) - predicted, pred_len)

window_end = predicted + window_pred_len

yield (token_list[window_end - max_seq_len - 1:window_end - 1], token_list[window_end - window_pred_len:window_end])

predicted += window_pred_len

def make_disjoint_window(pair):

(a, b) = pair

return (a[:len(a) - (len(b) - 1)], b)

class EnhancedJSONEncoder(json.JSONEncoder):

def default(self, o):

if is_dataclass(o):

return asdict(o)

return super().default(o)

class Reorderer:

def __init__(self, arr: List[Any], fn: Callable) -> None:

self.size = len(arr)

arr = list(enumerate(arr))

arr = group(arr, lambda x: fn(x[1]))

arr = [([y[0]], x[0][1]) for x in arr for y in x]

arr.sort(key=lambda x: fn(x[1]))

self.arr = arr

def get_reordered(self):

return [x[1] for x in self.arr]

def get_original(self, newarr):

res = [None] * self.size

cov = [False] * self.size

for ((inds, _), v) in zip(self.arr, newarr):

for ind in inds:

res[ind] = v

cov[ind] = True

assert all(cov)

return res

def make_table(result_dict, column: str='results', sort_results: bool=False):

from pytablewriter import LatexTableWriter, MarkdownTableWriter

if column == 'results':

column_name = 'Tasks'

elif column == 'groups':

column_name = 'Groups'

all_headers = [column_name, 'Version', 'Filter', 'n-shot', 'Metric', '', 'Value', '', 'Stderr']

md_writer = MarkdownTableWriter()

latex_writer = LatexTableWriter()

md_writer.headers = all_headers

latex_writer.headers = all_headers

values = []

keys = result_dict[column].keys()

if sort_results:

keys = sorted(keys)

for k in keys:

dic = result_dict[column][k]

version = result_dict['versions'].get(k, ' N/A')

n = str(result_dict.get('n-shot', ' ').get(k, ' '))

higher_is_better = result_dict.get('higher_is_better', {}).get(k, {})

if 'alias' in dic:

k = dic.pop('alias')

metric_items = dic.items()

metric_items = sorted(metric_items)

for (mf, v) in metric_items:

(m, _, f) = mf.partition(',')

if m.endswith('_stderr'):

continue

hib = HIGHER_IS_BETTER_SYMBOLS.get(higher_is_better.get(m), '')

v = '%.4f' % v if isinstance(v, float) else v

if m + '_stderr' + ',' + f in dic:

se = dic[m + '_stderr' + ',' + f]

se = ' N/A' if se == 'N/A' else '%.4f' % se

values.append([k, version, f, n, m, hib, v, '±', se])

else:

values.append([k, version, f, n, m, hib, v, '', ''])

k = ''

version = ''

md_writer.value_matrix = values

latex_writer.value_matrix = values