Datasets:
danidarko
/
docs

Dataset card Data Studio Files Community
1
text
stringlengths
0
15.3k
def filter_set(inst):
filtered_resp = []
for resp in inst:
resp = resp.lstrip()
filtered_resp.append(resp)
return filtered_resp
filtered_resps = [filter_set(resp) for resp in resps]
return filtered_resps
@register_filter('multi_choice_regex')
class MultiChoiceRegexFilter(RegexFilter):
def __init__(self, regex_pattern: str='#### (\\-?[0-9\\.\\,]+)', group_select=0, fallback: str='[invalid]', ignore_case=False, ignore_punctuation=False, regexes_to_ignore=None) -> None:
super().__init__(regex_pattern, group_select, fallback)
self.ignore_case = ignore_case
self.ignore_punctuation = ignore_punctuation
self.regexes_to_ignore = regexes_to_ignore
def apply(self, resps, docs):
def find_match(regex, resp, convert_dict={}):
match = regex.findall(resp)
if match:
match = match[self.group_select]
if isinstance(match, tuple):
match = [m for m in match if m][0]
match = match.strip()
if match and match in convert_dict:
match = convert_dict[match]
return match
punct_tbl = dict.fromkeys((i for i in range(sys.maxunicode) if unicodedata.category(chr(i)).startswith('P')))
def filter_ignores(st):
if self.regexes_to_ignore is not None:
for s in self.regexes_to_ignore:
st = re.sub(s, '', st)
if self.ignore_case:
st = st.lower()
if self.ignore_punctuation:
st = st.translate(punct_tbl)
return st
filtered_resps = []
for (r, doc) in zip(resps, docs):
fallback_regexes = []
choice_to_alpha = {}
next_alpha = 'A'
without_paren_fallback_regexes = []
without_paren_to_target = {}
choices = doc['choices']
for c in choices:
m = filter_ignores(c.strip())
fallback_regexes.append(f'{re.escape(m)}')
choice_to_alpha[m] = f'({next_alpha})'
without_paren_fallback_regexes.append(next_alpha)
without_paren_to_target[next_alpha] = f'({next_alpha})'
next_alpha = chr(ord(next_alpha) + 1)
fallback_regex = re.compile('|'.join(fallback_regexes))
without_paren_fallback_regex = '|'.join(without_paren_fallback_regexes)
without_paren_fallback_regex = re.compile(f':[\\s]*({without_paren_fallback_regex})')
filtered = []
for resp in r:
match = find_match(self.regex, resp)
if not match:
match = find_match(fallback_regex, filter_ignores(resp), choice_to_alpha)
if not match:
match = find_match(without_paren_fallback_regex, resp, without_paren_to_target)
if not match:
match = self.fallback
filtered.append(match)
filtered_resps.append(filtered)
return filtered_resps
# File: lm-evaluation-harness-main/lm_eval/filters/selection.py
from collections import Counter
from lm_eval.api.filter import Filter
from lm_eval.api.registry import register_filter
@register_filter('take_first')
class TakeFirstFilter(Filter):
def __init__(self) -> None:
def apply(self, resps, docs):
return map(lambda r: r[0], resps)
@register_filter('take_first_k')
class TakeKFilter(Filter):
def __init__(self, **kwargs) -> None:
self.k = kwargs.pop('k')
super().__init__(**kwargs)
def apply(self, resps, docs):
resps = list(resps)
assert len(resps[0]) >= self.k, f'Need at least {self.k} responses per doc to take first {self.k}, but got {len(resps[0])} only! Please increase TaskConfig.repeats .'
return map(lambda r: r[:self.k], resps)
@register_filter('majority_vote')
class MajorityVoteFilter(Filter):