Upload folder using huggingface_hub

README.md

@@ -0,0 +1,86 @@
+---
+license: apache-2.0
+tags:
+  - uv-script
+  - ner
+  - zero-shot
+  - gliner
+  - hf-jobs
+---
+
+# GLiNER UV Scripts
+
+Zero-shot named-entity recognition over Hugging Face datasets using [GLiNER](https://github.com/urchade/GLiNER). Pass a list of entity types at runtime — no fine-tuning required.
+
+| Script | What it does | Output |
+|---|---|---|
+| `extract-entities.py` | Extract entities from a text column with a custom set of types | New `entities` column (list of `{start, end, text, label, score}`) |
+
+## Quick start
+
+Run on any HF dataset with a text column. No setup — `uv` resolves dependencies inline.
+
+```bash
+# Local CPU (small samples)
+uv run extract-entities.py \
+    librarian-bots/model_cards_with_metadata \
+    yourname/model-cards-entities \
+    --text-column card \
+    --entity-types Person Organization Dataset Model Framework \
+    --max-samples 100
+```
+
+## On HF Jobs
+
+```bash
+# CPU job — fine for small/medium datasets, free or near-free
+hf jobs uv run --flavor cpu-basic --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/gliner/raw/main/extract-entities.py \
+    librarian-bots/model_cards_with_metadata \
+    yourname/model-cards-entities \
+    --text-column card \
+    --entity-types Person Organization Dataset Model Framework \
+    --max-samples 1000
+
+# GPU job — worth it once you're processing >~1000 samples
+hf jobs uv run --flavor t4-small --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/gliner/raw/main/extract-entities.py \
+    librarian-bots/model_cards_with_metadata \
+    yourname/model-cards-entities \
+    --text-column card \
+    --entity-types Person Organization Dataset Model Framework \
+    --device cuda \
+    --batch-size 32
+```
+
+## Recommended entity-type vocabularies
+
+GLiNER is open-vocabulary, so any string works. Some starting points:
+
+- **General news/web text**: `Person Organization Location Date Event`
+- **ML/AI text (e.g. model cards)**: `Person Organization Dataset Model Framework Metric License`
+- **Legal/policy**: `Person Organization Court Statute Date Jurisdiction`
+- **Biomedical**: `Drug Disease Gene Protein Symptom`
+
+Quality drops on very abstract or polysemous types — start simple, iterate.
+
+## Models
+
+Default: `urchade/gliner_multi-v2.1` (multilingual, ~600 MB). Override with `--gliner-model`.
+
+Other useful checkpoints:
+- `urchade/gliner_small-v2.1` — English, faster
+- `urchade/gliner_large-v2.1` — English, larger / higher quality
+- `knowledgator/gliner-multitask-large-v0.5` — multitask (NER + classification + relation)
+
+See the [Knowledgator org](https://huggingface.co/knowledgator) and [urchade's models](https://huggingface.co/urchade) for the full set.
+
+## Pairing with Label Studio
+
+Output of this script is a Hugging Face dataset of texts + extracted entities. To put those entities in front of human reviewers, see the `bootstrap-labels` skill (or the workflow it documents): pull this dataset's predictions into a Label Studio project for review, then export a corrected dataset back to the Hub.
+
+## Caveats
+
+- GLiNER predictions are **bootstrap labels** — useful as a starting point, not as ground truth. Plan a review pass before downstream training.
+- Texts longer than `--max-text-chars` (default 8000) are truncated. Long-form documents may need chunking + reassembly.
+- Entity types are case-sensitive labels in output. Pass them as you want them to appear.

extract-entities.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "gliner>=0.2.16",
+#     "datasets>=3.0",
+#     "huggingface-hub",
+#     "tqdm",
+# ]
+# ///
+"""
+Extract named entities from a text column of a HuggingFace dataset using GLiNER.
+
+GLiNER is a zero-shot NER model: you pass a list of entity types at inference
+time (e.g., "Person", "Organization", "Dataset"), no fine-tuning needed.
+
+Examples:
+    # Local CPU run on a small sample
+    uv run extract-entities.py \\
+        librarian-bots/model_cards_with_metadata \\
+        my-username/model-cards-entities \\
+        --text-column card \\
+        --entity-types Person Organization Dataset Model Framework \\
+        --max-samples 100
+
+    # On HF Jobs with a cheap GPU
+    hf jobs uv run --flavor t4-small \\
+        --secrets HF_TOKEN \\
+        https://huggingface.co/datasets/uv-scripts/gliner/raw/main/extract-entities.py \\
+        librarian-bots/model_cards_with_metadata \\
+        my-username/model-cards-entities \\
+        --text-column card \\
+        --entity-types Person Organization Dataset Model Framework \\
+        --max-samples 5000
+
+Output schema: original dataset columns + new `entities` column, where each
+row's `entities` is a list of dicts:
+    {"start": int, "end": int, "text": str, "label": str, "score": float}
+"""
+
+import argparse
+import logging
+import os
+import sys
+import time
+from typing import Any, Dict, List
+
+import torch
+from datasets import Dataset, Features, Sequence, Value, load_dataset
+from huggingface_hub import DatasetCard
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    datefmt="%H:%M:%S",
+)
+log = logging.getLogger(__name__)
+
+
+def parse_args():
+    p = argparse.ArgumentParser(
+        description="Bootstrap NER labels with GLiNER over a HuggingFace dataset",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    p.add_argument("input_dataset", help="HF dataset ID (e.g., 'org/dataset')")
+    p.add_argument("output_dataset", help="HF dataset ID for output (e.g., 'user/output')")
+    p.add_argument(
+        "--text-column",
+        default="text",
+        help="Name of the text column to run NER over (default: 'text')",
+    )
+    p.add_argument(
+        "--entity-types",
+        nargs="+",
+        required=True,
+        help="Space-separated entity types to extract (e.g., Person Organization Date)",
+    )
+    p.add_argument(
+        "--gliner-model",
+        default="urchade/gliner_multi-v2.1",
+        help="GLiNER model ID (default: urchade/gliner_multi-v2.1, multilingual)",
+    )
+    p.add_argument(
+        "--threshold",
+        type=float,
+        default=0.5,
+        help="Confidence threshold for entity extraction (default: 0.5)",
+    )
+    p.add_argument(
+        "--split",
+        default="train",
+        help="Dataset split to process (default: train)",
+    )
+    p.add_argument(
+        "--max-samples",
+        type=int,
+        default=None,
+        help="Process at most N samples (default: all)",
+    )
+    p.add_argument(
+        "--batch-size",
+        type=int,
+        default=8,
+        help="Batch size for inference (default: 8)",
+    )
+    p.add_argument(
+        "--device",
+        choices=["auto", "cpu", "cuda"],
+        default="auto",
+        help="Device for inference (default: auto — uses CUDA if available)",
+    )
+    p.add_argument(
+        "--max-text-chars",
+        type=int,
+        default=8000,
+        help="Truncate texts longer than this many characters (default: 8000)",
+    )
+    p.add_argument(
+        "--private",
+        action="store_true",
+        help="Push the output dataset as private",
+    )
+    return p.parse_args()
+
+
+def resolve_device(arg: str) -> str:
+    if arg == "cpu":
+        return "cpu"
+    if arg == "cuda":
+        if not torch.cuda.is_available():
+            log.warning("--device cuda requested but CUDA not available; falling back to CPU")
+            return "cpu"
+        return "cuda"
+    return "cuda" if torch.cuda.is_available() else "cpu"
+
+
+def normalize_entity(ent: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "start": int(ent["start"]),
+        "end": int(ent["end"]),
+        "text": str(ent["text"]),
+        "label": str(ent["label"]),
+        "score": float(ent.get("score", 0.0)),
+    }
+
+
+def build_card(args, n_processed: int, n_entities: int, elapsed_s: float, device: str) -> str:
+    return f"""---
+license: apache-2.0
+tags:
+  - ner
+  - gliner
+  - zero-shot
+  - bootstrap
+  - uv-script
+size_categories:
+  - n<10K
+---
+
+# {args.output_dataset}
+
+Bootstrap NER dataset produced by [`{args.gliner_model}`](https://huggingface.co/{args.gliner_model}) over [`{args.input_dataset}`](https://huggingface.co/datasets/{args.input_dataset}).
+
+Generated using [`uv-scripts/gliner/extract-entities.py`](https://huggingface.co/datasets/uv-scripts/gliner).
+
+## Provenance
+
+| | |
+|---|---|
+| Source dataset | `{args.input_dataset}` (split `{args.split}`) |
+| Text column | `{args.text_column}` |
+| Bootstrap model | `{args.gliner_model}` |
+| Entity types | `{', '.join(args.entity_types)}` |
+| Confidence threshold | {args.threshold} |
+| Samples processed | {n_processed} |
+| Total entities extracted | {n_entities} |
+| Inference device | `{device}` |
+| Wall clock | {elapsed_s:.1f}s ({n_processed / max(elapsed_s, 1e-9):.2f} samples/s) |
+
+## Schema
+
+Original `{args.input_dataset}` columns plus an `entities` column:
+
+```python
+entities: list of {{
+    "start": int,    # character offset, inclusive
+    "end": int,      # character offset, exclusive
+    "text": str,     # the matched span
+    "label": str,    # one of {args.entity_types}
+    "score": float,  # GLiNER confidence in [0, 1]
+}}
+```
+
+## Caveats
+
+- These are **bootstrap labels**, not human-reviewed. Treat low-confidence (< 0.7) entities as candidates for review.
+- GLiNER is zero-shot: changing `--entity-types` changes what it extracts, but quality varies by entity type.
+- Long texts were truncated at {args.max_text_chars} characters before inference.
+"""
+
+
+def main():
+    args = parse_args()
+    device = resolve_device(args.device)
+    log.info("Loading %s split=%s ...", args.input_dataset, args.split)
+    ds = load_dataset(args.input_dataset, split=args.split, streaming=False)
+
+    if args.text_column not in ds.column_names:
+        sys.exit(
+            f"--text-column '{args.text_column}' not in {ds.column_names}"
+        )
+
+    if args.max_samples is not None:
+        n = min(args.max_samples, len(ds))
+        ds = ds.select(range(n))
+        log.info("Selected %d samples", n)
+    else:
+        log.info("Processing full split: %d samples", len(ds))
+
+    log.info("Loading GLiNER %s on %s ...", args.gliner_model, device)
+    from gliner import GLiNER
+
+    model = GLiNER.from_pretrained(args.gliner_model)
+    if device == "cuda":
+        model = model.to("cuda")
+    model.eval()
+
+    n_entities = 0
+    started = time.time()
+
+    def add_entities(batch: Dict[str, List]) -> Dict[str, List]:
+        nonlocal n_entities
+        texts = [
+            (t or "")[: args.max_text_chars] for t in batch[args.text_column]
+        ]
+        entities_per_row = []
+        for text in texts:
+            if not text.strip():
+                entities_per_row.append([])
+                continue
+            try:
+                ents = model.predict_entities(
+                    text, args.entity_types, threshold=args.threshold
+                )
+            except Exception as e:
+                log.warning("predict_entities failed: %s; returning []", e)
+                ents = []
+            normalized = [normalize_entity(e) for e in ents]
+            n_entities += len(normalized)
+            entities_per_row.append(normalized)
+        return {"entities": entities_per_row}
+
+    log.info("Running inference (batch_size=%d) ...", args.batch_size)
+    ds = ds.map(
+        add_entities,
+        batched=True,
+        batch_size=args.batch_size,
+        desc="Extracting entities",
+    )
+
+    elapsed = time.time() - started
+    log.info(
+        "Done. %d entities across %d samples in %.1fs (%.2f samples/s)",
+        n_entities, len(ds), elapsed, len(ds) / max(elapsed, 1e-9),
+    )
+
+    log.info("Pushing to %s ...", args.output_dataset)
+    ds.push_to_hub(args.output_dataset, private=args.private)
+
+    DatasetCard(build_card(args, len(ds), n_entities, elapsed, device)).push_to_hub(
+        args.output_dataset, repo_type="dataset"
+    )
+
+    log.info("Done: https://huggingface.co/datasets/%s", args.output_dataset)
+
+
+if __name__ == "__main__":
+    main()