| """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) |
| |
| 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')) |
|
|
