Upload repackage.py with huggingface_hub

repackage.py

@@ -0,0 +1,163 @@
+"""Text-only Mind2Web preparation: native actions and DOM candidates, no screenshots."""
+from collections import Counter
+import hashlib
+import json
+from pathlib import Path
+import random
+import re
+
+from datasets import Dataset, DatasetDict, Features, Sequence, Value
+from huggingface_hub import snapshot_download
+
+SOURCE = 'osunlp/Mind2Web'
+REVISION = '17ece8eb89862368edc0cc806acee6fca5163474'
+
+
+def page_html(action):
+    # Remove indentation between tags; retain all native DOM content and node IDs.
+    return re.sub(r'>\s+<', '><', action['cleaned_html']).strip()
+
+
+def page_key(action):
+    return hashlib.sha256(page_html(action).encode()).hexdigest()
+
+
+def trajectory_splits(trajectories, seed=42):
+    """80/10/10 hash partitions of trajectories connected by identical DOM snapshots."""
+    parents, pages = {}, {}
+    def root(key):
+        parents.setdefault(key, key)
+        if parents[key] != key:
+            parents[key] = root(parents[key])
+        return parents[key]
+    for trajectory in trajectories:
+        identity = trajectory['annotation_id']
+        root(identity)
+        for action in trajectory['actions']:
+            key = page_key(action)
+            if key in pages:
+                a, b = root(identity), root(pages[key])
+                parents[max(a, b)] = min(a, b)
+            pages[key] = identity
+    groups = {identity: root(identity) for identity in parents}
+    splits = {}
+    for identity, group in groups.items():
+        value = int(hashlib.sha256(f'{seed}:{group}'.encode()).hexdigest(), 16) % 100
+        splits[identity] = 'train' if value < 80 else 'validation' if value < 90 else 'test'
+    return splits, groups
+
+
+def mind2web_record(trajectory, index, elements=False, seed=42):
+    """Gold flags/arguments stay out of inputs; alternative positives are never negatives."""
+    action = trajectory['actions'][index]
+    operation = action['operation']['op']
+    if operation not in ('CLICK', 'TYPE', 'SELECT'):
+        return None, 'unsupported_operation'
+    html = page_html(action)
+    if not html or not trajectory['confirmed_task'].strip():
+        return None, 'missing_context'
+    history = trajectory['action_reprs'][:index]
+    inputs = (f"Task: {trajectory['confirmed_task']}\nPrevious actions:\n" + '\n'.join(history)
+              + '\nDOM:\n' + html)
+    identity = f"{trajectory['annotation_id']}:{action['action_uid']}"
+    metadata = dict(id=identity, source_row=identity, trajectory_id=trajectory['annotation_id'],
+        action_uid=action['action_uid'], action_index=index, website=trajectory['website'],
+        domain=trajectory['domain'], source_dataset=SOURCE, source_revision=REVISION,
+        source_split='train', input_view='dom', page_group_id=page_key(action))
+    if not elements:
+        return dict(inputs=inputs, labels=operation, metadata=json.dumps(metadata, sort_keys=True)), None
+    positives = action['pos_candidates']
+    original = [candidate for candidate in positives if candidate.get('is_original_target') is True]
+    if len(original) != 1:
+        return None, 'ambiguous_or_missing_original_target'
+    positive_ids = {str(candidate['backend_node_id']) for candidate in positives}
+    nodes = set(re.findall(r'backend_node_id=["\']([^"\']+)["\']', html))
+    def describe(candidate):
+        node = str(candidate['backend_node_id'])
+        if node not in nodes:
+            return None
+        attributes = candidate['attributes']
+        attributes = json.loads(attributes) if isinstance(attributes, str) else attributes
+        visible = {key: attributes[key] for key in
+                   ('aria_label', 'aria-label', 'placeholder', 'title', 'role', 'type', 'id', 'text')
+                   if attributes.get(key)}
+        return node, json.dumps(dict(node=node, tag=candidate['tag'], attributes=visible),
+                                ensure_ascii=False, sort_keys=True)
+    gold = describe(original[0])
+    if gold is None:
+        return None, 'target_missing_from_dom'
+    negatives = {}
+    for candidate in action['neg_candidates']:
+        if str(candidate['backend_node_id']) not in positive_ids:
+            option = describe(candidate)
+            if option:
+                negatives[option[0]] = option
+    # Four native candidates match the normal text MC template; never invent negatives.
+    if len(negatives) < 3:
+        return None, 'fewer_than_three_native_negatives'
+    rng = random.Random(f'{seed}:{identity}')
+    choices = [gold] + rng.sample(sorted(negatives.values()), 3)
+    rng.shuffle(choices)
+    metadata.update(candidate_ids=[node for node, _ in choices], target_id=gold[0],
+                    candidate_sampling_seed=seed, native_negative_count=len(negatives))
+    return dict(inputs=inputs + f'\nOperation: {operation}', choices_list=[text for _, text in choices],
+                labels=choices.index(gold), metadata=json.dumps(metadata, sort_keys=True)), None
+
+
+def mind2web_dom(seed=42):
+    """Mind2Web public training trajectories as compact HTML-only actions and native MCQs.
+
+    Dataset annotations are CC BY 4.0: https://huggingface.co/datasets/osunlp/Mind2Web
+    No official benchmark test files are downloaded or republished. Derived 80/10/10
+    train/validation/test partitions group whole trajectories and identical cleaned DOM
+    snapshots. They are internal holdouts, not the official Mind2Web benchmark splits.
+    Only past actions enter context. Four-way MC uses the original target and three
+    deterministically sampled native negatives, excluding all alternative positives.
+    """
+    root = Path(snapshot_download(SOURCE, repo_type='dataset', revision=REVISION,
+                                 allow_patterns=['data/train/*.json']))
+    paths = sorted(root.glob('data/train/*.json'))
+    def trajectories():
+        for path in paths:
+            yield from json.loads(path.read_text())
+    splits, groups = trajectory_splits(trajectories(), seed)
+    output = Path('build/mind2web-dom-release')
+    output.mkdir(parents=True, exist_ok=True)
+    features = Features(dict(inputs=Value('string'), labels=Value('string'), metadata=Value('string')))
+    result, counts, exclusions = {}, Counter(), []
+    for view in ('action', 'dom-element'):
+        schema = features.copy()
+        if view == 'dom-element':
+            schema.update(labels=Value('int64'), choices_list=Sequence(Value('string')))
+        def rows():
+            for trajectory in trajectories():
+                for index in range(len(trajectory['actions'])):
+                    record, reason = mind2web_record(trajectory, index, view == 'dom-element', seed)
+                    split = splits[trajectory['annotation_id']]
+                    if reason:
+                        counts[f'{view}/{split}/excluded/{reason}'] += 1
+                        exclusions.append(dict(view=view, trajectory_id=trajectory['annotation_id'],
+                            action_uid=trajectory['actions'][index]['action_uid'], reason=reason))
+                        continue
+                    metadata = json.loads(record['metadata'])
+                    metadata.update(split_group_id=groups[trajectory['annotation_id']],
+                                    split_policy='public-train-connected-trajectories-80/10/10-v1', split_seed=seed)
+                    record['metadata'] = json.dumps(metadata, sort_keys=True)
+                    record['_split'] = split
+                    counts[f'{view}/{split}/included'] += 1
+                    yield record
+        full_schema = Features({**schema, '_split': Value('string')})
+        data = Dataset.from_generator(rows, features=full_schema, cache_dir=str(output / 'cache'))
+        result[view] = DatasetDict({split: data.filter(lambda row: row['_split'] == split).remove_columns('_split')
+                                  for split in ('train', 'validation', 'test')})
+        for split, dataset in result[view].items():
+            dataset.to_parquet(str(output / f'{view}-{split}.parquet'))
+    report = dict(source=SOURCE, revision=REVISION, seed=seed, counts=dict(counts),
+        split_policy='public-train-connected-trajectories-80/10/10-v1',
+        trajectory_splits=splits, trajectory_groups=groups,
+        source_sha256={p.name: hashlib.sha256(p.read_bytes()).hexdigest() for p in paths},
+        conversion_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+        license='cc-by-4.0', official_benchmark_tests_consumed=False)
+    (output / 'provenance.json').write_text(json.dumps(report, indent=2) + '\n')
+    (output / 'excluded-questions.jsonl').write_text(''.join(json.dumps(row) + '\n' for row in exclusions))
+    return result