File size: 11,133 Bytes
dbd1d56 | 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 | """Pinned entity sentiment and query relevance mirrors; no generated labels or negatives."""
import ast
from collections import Counter
import csv
import hashlib
import heapq
import io
import json
from pathlib import Path
import re
import urllib.request
from datasets import Dataset, DatasetDict, Features, Value
from huggingface_hub import snapshot_download
import pyarrow.parquet as pq
from .text import _split_of
SENTFIN_REVISION = 'eba43610fe3cb57a3e5773cd6c037da1f8992ad5'
WANDS_REVISION = '16cff4fbe4b46ee0b382e7901ee62461f88a2cb1'
SEARCH_REVISION = '781d35d1bf87253b3dcd0fadcb82bfbee9c244f1'
def text_key(text):
return hashlib.sha256(' '.join(text.casefold().split()).encode()).hexdigest()
def parse_sentfin(value):
"""Repair only the released unescaped-apostrophe dictionary representation."""
try:
result = ast.literal_eval(value)
repaired = False
except (ValueError, SyntaxError):
pattern = r"'(.*?)'\s*:\s*'(positive|neutral|negative)'(?=\s*[,}])"
pairs = re.findall(pattern, value)
remainder = re.sub(pattern, '', value).strip()
if not pairs or re.sub(r'[{},\s]', '', remainder) or len(dict(pairs)) != len(pairs):
raise ValueError('Unrecognized SEntFiN annotation representation')
result, repaired = dict(pairs), True
if not isinstance(result, dict) or not result or any(
not isinstance(k, str) or not k.strip() or v not in ('negative', 'neutral', 'positive')
for k, v in result.items()):
raise ValueError('Invalid SEntFiN entity sentiment')
return result, repaired
def write_mirror(name, splits, label_type, report):
directory = Path('build') / (name + '-release')
directory.mkdir(parents=True, exist_ok=True)
features = Features(dict(sentence1=Value('string'), sentence2=Value('string'),
labels=Value(label_type), metadata=Value('string')))
data = DatasetDict({split:Dataset.from_list(rows,features=features) for split,rows in splits.items()})
report.update(conversion_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
splits={s:len(d) for s,d in data.items()})
for split, rows in data.items():
rows.to_parquet(str(directory / (split + '.parquet')))
(directory/'excluded-questions.jsonl').write_text('')
(directory/'provenance.json').write_text(json.dumps(report,indent=2,ensure_ascii=False)+'\n')
return data
def sentfin():
"""SEntFiN entity sentiment, one native headline/entity judgment per row.
Pinned original CSV: https://github.com/pyRis/SEntFiN (repository MIT license).
Only malformed dictionary quoting is repaired; the original annotation string
and source row ID remain in metadata. Identical normalized headlines stay in
one deterministic 80/10/10 internal partition. These are derived holdouts, not
an official benchmark split. Duplicate pairs are deduplicated; contradictory
judgments for the same headline/entity are excluded and reported.
"""
url=f'https://raw.githubusercontent.com/pyRis/SEntFiN/{SENTFIN_REVISION}/SEntFiN.csv'
raw=urllib.request.urlopen(url).read()
records, repairs, conflicts, duplicates = {}, [], set(), 0
for row in csv.DictReader(io.StringIO(raw.decode())):
labels, repaired = parse_sentfin(row['Decisions'])
if repaired:
repairs.append(dict(id=row['S No.'], original=row['Decisions'], parsed=labels))
group=text_key(row['Title'])
for entity,label in labels.items():
key=(group,entity.casefold())
if key in records:
if records[key]['labels'] != label:
conflicts.add(key)
else:
duplicates += 1
continue
meta=dict(id=f"{row['S No.']}:{entity}", headline_id=row['S No.'], entity=entity,
split_group_id=group, source_url=url, source_revision=SENTFIN_REVISION,
source_annotation=row['Decisions'], quoting_repaired=repaired)
records[key]=dict(sentence1=row['Title'],sentence2=entity,labels=label,
metadata=json.dumps(meta,ensure_ascii=False,sort_keys=True))
splits={s:[] for s in ('train','validation','test')}
for (group,entity),row in records.items():
if (group,entity) not in conflicts:
splits[_split_of(group)].append(row)
return write_mirror('sentfin',splits,'string',dict(source_url=url,revision=SENTFIN_REVISION,
source_sha256=hashlib.sha256(raw).hexdigest(),repairs=repairs,duplicate_pairs=duplicates,
excluded_conflicting_pairs=[list(k) for k in sorted(conflicts)],
split_policy='normalized-headline-hash-80/10/10',license='mit',
license_url=f'https://github.com/pyRis/SEntFiN/blob/{SENTFIN_REVISION}/LICENSE'))
def wands():
"""WANDS native three-grade product relevance with query-disjoint internal holdouts.
Original Wayfair data: https://github.com/wayfair/WANDS (MIT).
Uses the pinned joined napsternxg/wands Hub copy; its random row splits overlap
on queries and are replaced by deterministic 80/10/10 normalized-query groups.
All native judgments are retained. Inputs contain query and product content;
popularity/rating fields and relevance labels never enter model inputs.
"""
root=Path(snapshot_download('napsternxg/wands',repo_type='dataset',revision=WANDS_REVISION,
allow_patterns=['data/*.parquet']))
splits={s:[] for s in ('train','validation','test')}
counts=Counter()
for path in sorted(root.glob('data/*.parquet')):
for batch in pq.ParquetFile(path).iter_batches(batch_size=512):
for row in batch.to_pylist():
if row['label'] not in (0,1,2):
raise ValueError('Unknown WANDS relevance grade')
group=text_key(row['query'])
fields=('product_name','product_class','category hierarchy','product_description','product_features')
product='\n'.join(f'{key}: {row[key]}' for key in fields if row.get(key))
meta=dict(id=str(row['id']),query_id=row['query_id'],product_id=row['product_id'],
split_group_id=group,original_mirror_split=path.name.split('-')[0],
source_dataset='napsternxg/wands',source_revision=WANDS_REVISION)
splits[_split_of(group)].append(dict(sentence1=row['query'],sentence2=product,
labels=row['label'],metadata=json.dumps(meta,sort_keys=True)))
counts[row['label']] += 1
return write_mirror('wands',splits,'int64',dict(source='napsternxg/wands',revision=WANDS_REVISION,
original_source='https://github.com/wayfair/WANDS',label_counts=dict(counts),
source_sha256={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in root.glob('data/*.parquet')},
split_policy='normalized-query-hash-80/10/10',license='mit',
license_url='https://github.com/wayfair/WANDS/blob/3b74dcf4ba29ab8ff3e6a50b5b09fc627cb882b5/LICENSE'))
def search_record(row, candidate):
score=candidate['score']
if not isinstance(score,(int,float)) or not 0 <= score <= 14:
raise ValueError(f'Unexpected SciRepEval click-derived score: {score}')
document='\n'.join(v for v in (candidate.get('title'),candidate.get('abstract')) if v)
if not document.strip() or not row['query'].strip():
return None
group=text_key(row['query'])
meta=dict(id=f"{row['doc_id']}:{candidate['doc_id']}",query_id=row['doc_id'],
candidate_id=candidate['doc_id'],split_group_id=group,source_revision=SEARCH_REVISION,
source_score=score,supervision='click-derived score, not a human relevance rating',
score_anchors=list(range(0,15,2)),score_interpolation='linear; expected score equals native value')
return dict(sentence1=row['query'],sentence2=document,labels=float(score),metadata=json.dumps(meta,sort_keys=True))
def scirepeval_search(max_rows=5000, max_rows_eval=500, seed=42):
"""SciRepEval Search native train/validation pairs with raw click-derived numeric scores.
No evaluation/test benchmark data is consumed. All training/validation shards
are scanned; deterministic hash sampling covers eligible pairs from the entire
source, not an early prefix. Validation queries seen in training are excluded.
Scores remain unchanged. Jev uses linear interpolation over eight anchors
0,2,...,14 to preserve the numeric expectation within its 10-level limit.
Dataset/text licensing is unspecified: the code's Apache license is not used
as a grant for paper abstracts. Evidence and exclusions remain in provenance.
"""
root=Path(snapshot_download('allenai/scirepeval',repo_type='dataset',revision=SEARCH_REVISION,
allow_patterns=['search/train-*.parquet','search/validation-*.parquet'],max_workers=4))
splits, counts, train_groups = {}, Counter(), set()
scores=Counter()
for split,limit in [('train',max_rows),('validation',max_rows_eval)]:
pool=[]
for path in sorted(root.glob(f'search/{split}-*.parquet')):
for batch in pq.ParquetFile(path).iter_batches(batch_size=64):
for source in batch.to_pylist():
group=text_key(source['query'])
if split=='validation' and group in train_groups:
counts['validation/excluded/query_overlap'] += len(source['candidates'])
continue
if split=='train':
train_groups.add(group)
for candidate in source['candidates']:
record=search_record(source,candidate)
if record is None:
counts[split+'/excluded/missing_text'] += 1
continue
counts[split+'/eligible'] += 1
scores[candidate['score']] += 1
identity=f"{source['doc_id']}:{candidate['doc_id']}"
rank=-int(hashlib.sha256(f'{seed}:{identity}'.encode()).hexdigest(),16)
item=(rank,identity,counts[split+'/eligible'],record)
if len(pool)<limit:
heapq.heappush(pool,item)
elif item[:2]>pool[0][:2]:
heapq.heapreplace(pool,item)
# Duplicate native query/candidate pairs must not become duplicated training examples.
selected={identity:record for _,identity,_,record in sorted(pool)}
splits[split]=list(selected.values())
return write_mirror('scirepeval-search',splits,'float64',dict(source='allenai/scirepeval',
revision=SEARCH_REVISION,config='search',counts=dict(counts),source_score_counts=dict(scores),
selection=dict(max_rows=max_rows,max_rows_eval=max_rows_eval,seed=seed,method='full-source hash sample'),
split_policy='native train/validation; validation queries in train excluded',license='unspecified'))
|