Upload folder using huggingface_hub

README.md

@@ -0,0 +1,171 @@
+---
+license: mit
+task_categories:
+  - text-classification
+  - summarization
+language:
+  - en
+tags:
+  - arxiv
+  - academic-papers
+  - research
+  - computer-science
+  - machine-learning
+size_categories:
+  - 1K<n<10K
+---
+
+# CS/ML Academic Papers Dataset
+
+A curated dataset of academic paper metadata sourced from [arXiv](https://arxiv.org/), spanning key Computer Science and Machine Learning categories. Designed for research in text classification, topic modelling, summarisation, and scientometric analysis.
+
+## Dataset Description
+
+### Overview
+
+This dataset contains metadata for **2,500+** recently published papers across five core arXiv categories at the intersection of computer science and machine learning:
+
+| Category  | Description                         |
+|-----------|-------------------------------------|
+| `cs.AI`   | Artificial Intelligence             |
+| `cs.CL`   | Computation and Language (NLP)      |
+| `cs.CV`   | Computer Vision and Pattern Recog.  |
+| `cs.LG`   | Machine Learning                    |
+| `stat.ML` | Statistics — Machine Learning       |
+
+Papers are sorted by submission date (most recent first) and deduplicated by arXiv ID, so cross-listed papers appear only once.
+
+### Collection Methodology
+
+1. The [arXiv API](https://info.arxiv.org/help/api/index.html) is queried via the [`arxiv`](https://pypi.org/project/arxiv/) Python package.
+2. For each of the five categories, the 500 most recent papers are fetched (configurable).
+3. Results are deduplicated on `arxiv_id` — papers cross-listed in multiple categories keep only their first occurrence.
+4. Rate limiting (3.5 s between pages, 5 retries on failure) ensures compliance with arXiv's API Terms of Service.
+
+The collection script is fully reproducible: see [`create_dataset.py`](create_dataset.py).
+
+### Schema
+
+| Column             | Type           | Description                                              |
+|--------------------|----------------|----------------------------------------------------------|
+| `arxiv_id`         | `string`       | arXiv identifier (e.g. `2401.12345v1`)                   |
+| `title`            | `string`       | Paper title, whitespace-normalised                       |
+| `abstract`         | `string`       | Full abstract text, whitespace-normalised                |
+| `authors`          | `list[string]` | Ordered list of author names                             |
+| `categories`       | `list[string]` | All arXiv categories assigned to the paper               |
+| `primary_category` | `string`       | The primary arXiv category                               |
+| `published`        | `string`       | ISO-8601 publication timestamp                           |
+| `updated`          | `string`       | ISO-8601 last-updated timestamp                          |
+| `doi`              | `string`       | Digital Object Identifier (empty string if unavailable)  |
+| `url`              | `string`       | Canonical arXiv abstract URL                             |
+
+### Splits
+
+| Split   | Approximate Size |
+|---------|------------------|
+| `train` | ~90 %            |
+| `test`  | ~10 %            |
+
+The split is performed with a fixed random seed (`42`) for reproducibility.
+
+## Intended Uses
+
+- **Text classification** — predict the primary arXiv category from the title or abstract.
+- **Summarisation** — generate concise summaries from abstracts or use titles as abstractive targets.
+- **Topic modelling** — discover latent research themes across categories.
+- **Scientometrics** — analyse publication trends, author collaboration patterns, and category overlap.
+- **Information retrieval** — build search or recommendation engines over academic literature.
+
+## Example
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("gr8monk3ys/cs-ml-academic-papers")
+
+# Peek at the first training example
+print(ds["train"][0])
+# {
+#     "arxiv_id": "2401.12345v1",
+#     "title": "An Example Paper on Large Language Models",
+#     "abstract": "We propose a novel method for ...",
+#     "authors": ["Alice Researcher", "Bob Scientist"],
+#     "categories": ["cs.CL", "cs.AI"],
+#     "primary_category": "cs.CL",
+#     "published": "2024-01-20T18:00:00+00:00",
+#     "updated": "2024-01-22T12:30:00+00:00",
+#     "doi": "10.1234/example.2024.001",
+#     "url": "http://arxiv.org/abs/2401.12345v1"
+#  }
+```
+
+## Reproducing the Dataset
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Fetch papers and save locally (Parquet + HF Dataset format)
+python create_dataset.py
+
+# Optionally push to the HuggingFace Hub
+python create_dataset.py --push --hf-repo gr8monk3ys/cs-ml-academic-papers
+
+# Run exploratory data analysis and generate plots
+python explore_dataset.py
+```
+
+### CLI Options — `create_dataset.py`
+
+| Flag              | Default                              | Description                            |
+|-------------------|--------------------------------------|----------------------------------------|
+| `--per-category`  | `500`                                | Papers to fetch per arXiv category     |
+| `--push`          | off                                  | Push dataset to HuggingFace Hub        |
+| `--hf-repo`       | `gr8monk3ys/cs-ml-academic-papers`   | Hub repository ID                      |
+| `--output-dir`    | `./data`                             | Local output directory                 |
+| `--verbose`       | off                                  | Enable debug logging                   |
+
+### CLI Options — `explore_dataset.py`
+
+| Flag           | Default                              | Description                            |
+|----------------|--------------------------------------|----------------------------------------|
+| `--data-dir`   | `./data`                             | Local data directory                   |
+| `--from-hub`   | —                                    | Load from HF Hub repo instead          |
+| `--plots-dir`  | `./plots`                            | Output directory for PNG plots         |
+| `--verbose`    | off                                  | Enable debug logging                   |
+
+## Generated Visualisations
+
+The EDA script (`explore_dataset.py`) produces the following plots:
+
+- **category_distribution.png** — horizontal bar chart of paper counts per primary category.
+- **abstract_length_histogram.png** — word-count distribution of abstracts with mean/median markers.
+- **abstract_length_by_category.png** — box plots comparing abstract lengths across categories.
+- **authors_per_paper.png** — histogram of author counts.
+- **publication_timeline.png** — monthly publication volume over time.
+- **tfidf_terms_heatmap.png** — heatmap of the top TF-IDF terms per category.
+
+## Limitations and Bias
+
+- The dataset is a **snapshot** — arXiv receives thousands of new submissions daily; re-running the collection script at different times will produce different results.
+- Only **five categories** are included. Many relevant papers (e.g., `cs.IR`, `cs.RO`, `math.OC`) are excluded.
+- Papers cross-listed under multiple categories are kept only once, so secondary categories are under-represented in the primary-category distribution.
+- Metadata only — **full paper text and PDFs are not included**.
+
+## Citation
+
+If you use this dataset in your work, please cite it as:
+
+```bibtex
+@misc{scaturchio2024csml_papers,
+  author       = {Lorenzo Scaturchio},
+  title        = {{CS/ML Academic Papers Dataset}},
+  year         = {2024},
+  publisher    = {HuggingFace},
+  howpublished = {\url{https://huggingface.co/datasets/gr8monk3ys/cs-ml-academic-papers}},
+}
+```
+
+## License
+
+This dataset is released under the [MIT License](https://opensource.org/licenses/MIT). The underlying paper metadata is sourced from arXiv and is subject to arXiv's [Terms of Use](https://info.arxiv.org/help/api/tou.html).

create_dataset.py

@@ -0,0 +1,324 @@
+#!/usr/bin/env python3
+"""
+create_dataset.py
+
+Fetches academic paper metadata from the arXiv API across multiple CS/ML
+categories, deduplicates the results, and publishes a clean HuggingFace
+Dataset in Parquet format.
+
+Usage
+-----
+    # Fetch papers and save locally
+    python create_dataset.py
+
+    # Fetch papers and push to the HuggingFace Hub
+    python create_dataset.py --push --hf-repo gr8monk3ys/cs-ml-academic-papers
+
+    # Customise the number of papers per category
+    python create_dataset.py --per-category 1000
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import re
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import arxiv
+import pandas as pd
+from datasets import Dataset, DatasetDict, Features, Sequence, Value
+from huggingface_hub import HfApi
+from tqdm import tqdm
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+CATEGORIES: list[str] = ["cs.AI", "cs.CL", "cs.CV", "cs.LG", "stat.ML"]
+
+DEFAULT_PER_CATEGORY: int = 500
+
+# arXiv API courtesy: wait between successive queries to avoid rate-limiting.
+# The arXiv API Terms of Service recommend no more than one request every
+# three seconds.  We are conservative and wait a bit longer between pages.
+REQUEST_DELAY_SECONDS: float = 3.5
+
+# Each arXiv search page can return at most this many results.
+PAGE_SIZE: int = 100
+
+OUTPUT_DIR: Path = Path(__file__).resolve().parent / "data"
+
+LOG = logging.getLogger("create_dataset")
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _clean_text(text: str) -> str:
+    """Collapse whitespace and strip leading/trailing blanks."""
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def _extract_doi(entry: arxiv.Result) -> str:
+    """Return the DOI if present, otherwise an empty string."""
+    return entry.doi or ""
+
+
+def _extract_authors(entry: arxiv.Result) -> list[str]:
+    """Return a sorted list of author names."""
+    return [str(a) for a in entry.authors]
+
+
+def _entry_to_record(entry: arxiv.Result) -> dict[str, Any]:
+    """Convert an arxiv.Result into a flat dictionary."""
+    return {
+        "arxiv_id": entry.entry_id.split("/abs/")[-1],
+        "title": _clean_text(entry.title),
+        "abstract": _clean_text(entry.summary),
+        "authors": _extract_authors(entry),
+        "categories": list(entry.categories),
+        "primary_category": entry.primary_category,
+        "published": entry.published.isoformat() if entry.published else "",
+        "updated": entry.updated.isoformat() if entry.updated else "",
+        "doi": _extract_doi(entry),
+        "url": entry.entry_id,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Fetching
+# ---------------------------------------------------------------------------
+
+
+def fetch_papers_for_category(
+    category: str,
+    max_results: int = DEFAULT_PER_CATEGORY,
+) -> list[dict[str, Any]]:
+    """
+    Query the arXiv API for papers in *category*, respecting rate limits.
+
+    Parameters
+    ----------
+    category:
+        An arXiv category string such as ``"cs.AI"`` or ``"stat.ML"``.
+    max_results:
+        Maximum number of papers to retrieve for this category.
+
+    Returns
+    -------
+    list[dict]
+        A list of paper-metadata dictionaries.
+    """
+    LOG.info("Fetching up to %d papers for category: %s", max_results, category)
+
+    search = arxiv.Search(
+        query=f"cat:{category}",
+        max_results=max_results,
+        sort_by=arxiv.SortCriterion.SubmittedDate,
+        sort_order=arxiv.SortOrder.Descending,
+    )
+
+    client = arxiv.Client(
+        page_size=PAGE_SIZE,
+        delay_seconds=REQUEST_DELAY_SECONDS,
+        num_retries=5,
+    )
+
+    records: list[dict[str, Any]] = []
+    try:
+        for entry in tqdm(
+            client.results(search),
+            total=max_results,
+            desc=f"  {category}",
+            unit="paper",
+        ):
+            records.append(_entry_to_record(entry))
+    except arxiv.UnexpectedEmptyPageError:
+        LOG.warning(
+            "Received an empty page from arXiv for %s after %d results. "
+            "Continuing with what we have.",
+            category,
+            len(records),
+        )
+    except arxiv.HTTPError as exc:
+        LOG.error(
+            "HTTP error while fetching %s (collected %d so far): %s",
+            category,
+            len(records),
+            exc,
+        )
+
+    LOG.info("Collected %d papers for %s", len(records), category)
+    return records
+
+
+def fetch_all_papers(
+    categories: list[str] | None = None,
+    per_category: int = DEFAULT_PER_CATEGORY,
+) -> pd.DataFrame:
+    """
+    Fetch papers across all requested categories and return a deduplicated
+    :class:`pandas.DataFrame`.
+    """
+    categories = categories or CATEGORIES
+    all_records: list[dict[str, Any]] = []
+
+    for cat in categories:
+        records = fetch_papers_for_category(cat, max_results=per_category)
+        all_records.extend(records)
+        # Extra courtesy pause between categories
+        LOG.info("Pausing between categories ...")
+        time.sleep(REQUEST_DELAY_SECONDS)
+
+    df = pd.DataFrame(all_records)
+    before = len(df)
+    df = df.drop_duplicates(subset=["arxiv_id"], keep="first").reset_index(drop=True)
+    after = len(df)
+    LOG.info(
+        "Deduplicated %d -> %d records (%d duplicates removed)",
+        before,
+        after,
+        before - after,
+    )
+    return df
+
+
+# ---------------------------------------------------------------------------
+# Dataset creation
+# ---------------------------------------------------------------------------
+
+FEATURES = Features(
+    {
+        "arxiv_id": Value("string"),
+        "title": Value("string"),
+        "abstract": Value("string"),
+        "authors": Sequence(Value("string")),
+        "categories": Sequence(Value("string")),
+        "primary_category": Value("string"),
+        "published": Value("string"),
+        "updated": Value("string"),
+        "doi": Value("string"),
+        "url": Value("string"),
+    }
+)
+
+
+def build_dataset(df: pd.DataFrame) -> DatasetDict:
+    """
+    Convert a :class:`pandas.DataFrame` of paper records into a
+    :class:`datasets.DatasetDict` with ``train`` / ``test`` splits
+    (90 / 10).
+    """
+    dataset = Dataset.from_pandas(df, features=FEATURES, preserve_index=False)
+    splits = dataset.train_test_split(test_size=0.1, seed=42)
+    return DatasetDict({"train": splits["train"], "test": splits["test"]})
+
+
+def save_dataset(dataset_dict: DatasetDict, output_dir: Path) -> None:
+    """Save the dataset to disk in Parquet format."""
+    output_dir.mkdir(parents=True, exist_ok=True)
+    dataset_dict.save_to_disk(str(output_dir / "hf_dataset"))
+
+    # Also save individual Parquet files for easy inspection.
+    for split_name, split_ds in dataset_dict.items():
+        parquet_path = output_dir / f"{split_name}.parquet"
+        split_ds.to_parquet(str(parquet_path))
+        LOG.info("Saved %s split (%d rows) -> %s", split_name, len(split_ds), parquet_path)
+
+
+def push_to_hub(dataset_dict: DatasetDict, repo_id: str) -> None:
+    """Push the dataset to the HuggingFace Hub."""
+    LOG.info("Pushing dataset to HuggingFace Hub: %s", repo_id)
+    dataset_dict.push_to_hub(repo_id, private=False)
+    LOG.info("Successfully pushed to %s", repo_id)
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Fetch arXiv paper metadata and create a HuggingFace Dataset.",
+    )
+    parser.add_argument(
+        "--per-category",
+        type=int,
+        default=DEFAULT_PER_CATEGORY,
+        help=f"Number of papers to fetch per category (default: {DEFAULT_PER_CATEGORY}).",
+    )
+    parser.add_argument(
+        "--push",
+        action="store_true",
+        help="Push the dataset to the HuggingFace Hub after creation.",
+    )
+    parser.add_argument(
+        "--hf-repo",
+        type=str,
+        default="gr8monk3ys/cs-ml-academic-papers",
+        help="HuggingFace Hub repo ID (default: gr8monk3ys/cs-ml-academic-papers).",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default=str(OUTPUT_DIR),
+        help=f"Local output directory (default: {OUTPUT_DIR}).",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable debug logging.",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(asctime)s  %(levelname)-8s  %(name)s  %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    output_dir = Path(args.output_dir)
+    LOG.info("=" * 60)
+    LOG.info("arXiv Academic Papers Dataset Builder")
+    LOG.info("=" * 60)
+    LOG.info("Categories      : %s", ", ".join(CATEGORIES))
+    LOG.info("Per category    : %d", args.per_category)
+    LOG.info("Output directory: %s", output_dir)
+    LOG.info("")
+
+    start = time.time()
+
+    # 1. Fetch ----------------------------------------------------------
+    df = fetch_all_papers(per_category=args.per_category)
+
+    # 2. Build dataset --------------------------------------------------
+    dataset_dict = build_dataset(df)
+    LOG.info(
+        "Dataset built — train: %d, test: %d",
+        len(dataset_dict["train"]),
+        len(dataset_dict["test"]),
+    )
+
+    # 3. Save locally ---------------------------------------------------
+    save_dataset(dataset_dict, output_dir)
+
+    # 4. (Optional) push to Hub -----------------------------------------
+    if args.push:
+        push_to_hub(dataset_dict, args.hf_repo)
+
+    elapsed = time.time() - start
+    LOG.info("Done in %.1f seconds.", elapsed)
+
+
+if __name__ == "__main__":
+    main()

explore_dataset.py

@@ -0,0 +1,420 @@
+#!/usr/bin/env python3
+"""
+explore_dataset.py
+
+Exploratory Data Analysis (EDA) for the CS/ML Academic Papers Dataset.
+
+Loads the locally-saved dataset (or downloads from HuggingFace Hub), computes
+summary statistics, identifies top terms per category via TF-IDF, and saves
+publication-ready visualisations as PNG files.
+
+Usage
+-----
+    # Analyse the local dataset
+    python explore_dataset.py
+
+    # Load from the HuggingFace Hub instead
+    python explore_dataset.py --from-hub gr8monk3ys/cs-ml-academic-papers
+
+    # Customise the output directory for plots
+    python explore_dataset.py --plots-dir ./plots
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import textwrap
+from collections import Counter
+from pathlib import Path
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from datasets import DatasetDict, load_from_disk
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+# Use non-interactive backend so the script works headlessly.
+matplotlib.use("Agg")
+
+LOG = logging.getLogger("explore_dataset")
+
+DATA_DIR: Path = Path(__file__).resolve().parent / "data"
+PLOTS_DIR: Path = Path(__file__).resolve().parent / "plots"
+
+# Colour palette (colour-blind friendly, adapted from Tol's muted scheme).
+PALETTE = ["#332288", "#88CCEE", "#44AA99", "#117733", "#999933",
+           "#DDCC77", "#CC6677", "#882255", "#AA4499"]
+
+# ---------------------------------------------------------------------------
+# Loading helpers
+# ---------------------------------------------------------------------------
+
+
+def load_local(data_dir: Path) -> pd.DataFrame:
+    """Load the dataset from a local ``save_to_disk`` directory."""
+    ds_path = data_dir / "hf_dataset"
+    if not ds_path.exists():
+        raise FileNotFoundError(
+            f"No saved dataset found at {ds_path}. "
+            "Run create_dataset.py first or use --from-hub."
+        )
+    dd = load_from_disk(str(ds_path))
+    frames = [dd[split].to_pandas() for split in dd]
+    return pd.concat(frames, ignore_index=True)
+
+
+def load_hub(repo_id: str) -> pd.DataFrame:
+    """Download the dataset from the HuggingFace Hub."""
+    from datasets import load_dataset
+
+    dd = load_dataset(repo_id)
+    frames = [dd[split].to_pandas() for split in dd]
+    return pd.concat(frames, ignore_index=True)
+
+
+# ---------------------------------------------------------------------------
+# Statistics
+# ---------------------------------------------------------------------------
+
+
+def print_summary(df: pd.DataFrame) -> None:
+    """Print high-level summary statistics to stdout."""
+    separator = "=" * 60
+    print(f"\n{separator}")
+    print("  CS/ML Academic Papers Dataset — Summary Statistics")
+    print(separator)
+
+    print(f"\n  Total papers           : {len(df):,}")
+    print(f"  Unique arXiv IDs       : {df['arxiv_id'].nunique():,}")
+    print(f"  Unique primary cats    : {df['primary_category'].nunique()}")
+
+    # Date range
+    if "published" in df.columns:
+        dates = pd.to_datetime(df["published"], errors="coerce")
+        valid = dates.dropna()
+        if len(valid) > 0:
+            print(f"  Published date range   : {valid.min():%Y-%m-%d} to {valid.max():%Y-%m-%d}")
+
+    # Authors
+    author_counts = df["authors"].apply(len)
+    print(f"\n  Authors per paper (mean): {author_counts.mean():.1f}")
+    print(f"  Authors per paper (med) : {author_counts.median():.0f}")
+
+    # Abstract lengths
+    abs_len = df["abstract"].str.split().str.len()
+    print(f"\n  Abstract length (words):")
+    print(f"    mean   : {abs_len.mean():.0f}")
+    print(f"    median : {abs_len.median():.0f}")
+    print(f"    min    : {abs_len.min():.0f}")
+    print(f"    max    : {abs_len.max():.0f}")
+    print(f"    std    : {abs_len.std():.1f}")
+
+    # Category distribution
+    print(f"\n  Primary category distribution:")
+    for cat, count in df["primary_category"].value_counts().items():
+        pct = 100.0 * count / len(df)
+        print(f"    {cat:<12s}  {count:>5,}  ({pct:5.1f}%)")
+
+    # DOI availability
+    has_doi = (df["doi"].str.len() > 0).sum()
+    print(f"\n  Papers with DOI        : {has_doi:,} ({100*has_doi/len(df):.1f}%)")
+
+    print(f"\n{separator}\n")
+
+
+# ---------------------------------------------------------------------------
+# TF-IDF keyword extraction
+# ---------------------------------------------------------------------------
+
+
+def top_tfidf_terms(
+    df: pd.DataFrame,
+    text_col: str = "abstract",
+    group_col: str = "primary_category",
+    top_n: int = 15,
+) -> dict[str, list[tuple[str, float]]]:
+    """
+    For each group in *group_col*, fit a TF-IDF vectoriser on the documents
+    belonging to that group and return the top-*n* terms by mean TF-IDF score.
+    """
+    results: dict[str, list[tuple[str, float]]] = {}
+
+    vectorizer = TfidfVectorizer(
+        max_features=5000,
+        stop_words="english",
+        min_df=5,
+        max_df=0.85,
+        ngram_range=(1, 2),
+        token_pattern=r"(?u)\b[a-zA-Z][a-zA-Z+#\-]{2,}\b",
+    )
+
+    for group, sub_df in df.groupby(group_col):
+        texts = sub_df[text_col].tolist()
+        if len(texts) < 10:
+            LOG.warning("Skipping group %s — too few documents (%d).", group, len(texts))
+            continue
+
+        tfidf_matrix = vectorizer.fit_transform(texts)
+        mean_scores = np.asarray(tfidf_matrix.mean(axis=0)).flatten()
+        feature_names = vectorizer.get_feature_names_out()
+        top_indices = mean_scores.argsort()[::-1][:top_n]
+        results[group] = [
+            (feature_names[i], float(mean_scores[i])) for i in top_indices
+        ]
+
+    return results
+
+
+def print_top_terms(terms_by_cat: dict[str, list[tuple[str, float]]]) -> None:
+    """Pretty-print TF-IDF top terms per category."""
+    print("=" * 60)
+    print("  Top TF-IDF Terms per Category")
+    print("=" * 60)
+    for cat in sorted(terms_by_cat):
+        print(f"\n  [{cat}]")
+        for rank, (term, score) in enumerate(terms_by_cat[cat], 1):
+            print(f"    {rank:>2}. {term:<30s}  (score: {score:.4f})")
+    print()
+
+
+# ---------------------------------------------------------------------------
+# Visualisations
+# ---------------------------------------------------------------------------
+
+
+def _savefig(fig: plt.Figure, path: Path) -> None:
+    fig.savefig(str(path), dpi=150, bbox_inches="tight", facecolor="white")
+    plt.close(fig)
+    LOG.info("Saved plot -> %s", path)
+
+
+def plot_category_distribution(df: pd.DataFrame, output_dir: Path) -> None:
+    """Bar chart of primary-category counts."""
+    counts = df["primary_category"].value_counts().sort_values(ascending=True)
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+    bars = ax.barh(counts.index, counts.values, color=PALETTE[: len(counts)])
+    ax.bar_label(bars, padding=4, fontsize=9)
+    ax.set_xlabel("Number of Papers")
+    ax.set_title("Papers by Primary arXiv Category")
+    ax.spines[["top", "right"]].set_visible(False)
+    fig.tight_layout()
+    _savefig(fig, output_dir / "category_distribution.png")
+
+
+def plot_abstract_length_histogram(df: pd.DataFrame, output_dir: Path) -> None:
+    """Histogram of abstract word counts."""
+    lengths = df["abstract"].str.split().str.len()
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+    ax.hist(lengths, bins=50, color=PALETTE[0], edgecolor="white", alpha=0.85)
+    ax.axvline(lengths.median(), color=PALETTE[6], linestyle="--", linewidth=1.5,
+               label=f"Median ({lengths.median():.0f} words)")
+    ax.axvline(lengths.mean(), color=PALETTE[4], linestyle=":", linewidth=1.5,
+               label=f"Mean ({lengths.mean():.0f} words)")
+    ax.set_xlabel("Abstract Length (words)")
+    ax.set_ylabel("Frequency")
+    ax.set_title("Distribution of Abstract Lengths")
+    ax.legend(frameon=False)
+    ax.spines[["top", "right"]].set_visible(False)
+    fig.tight_layout()
+    _savefig(fig, output_dir / "abstract_length_histogram.png")
+
+
+def plot_abstract_length_by_category(df: pd.DataFrame, output_dir: Path) -> None:
+    """Box plot of abstract lengths grouped by primary category."""
+    df = df.copy()
+    df["abstract_words"] = df["abstract"].str.split().str.len()
+
+    cats = df["primary_category"].value_counts().index.tolist()
+    data = [df.loc[df["primary_category"] == c, "abstract_words"].values for c in cats]
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+    bp = ax.boxplot(data, labels=cats, patch_artist=True, showfliers=False)
+    for patch, colour in zip(bp["boxes"], PALETTE):
+        patch.set_facecolor(colour)
+        patch.set_alpha(0.7)
+    ax.set_ylabel("Abstract Length (words)")
+    ax.set_title("Abstract Length by Primary Category")
+    ax.spines[["top", "right"]].set_visible(False)
+    fig.tight_layout()
+    _savefig(fig, output_dir / "abstract_length_by_category.png")
+
+
+def plot_authors_per_paper(df: pd.DataFrame, output_dir: Path) -> None:
+    """Histogram of author counts per paper."""
+    author_counts = df["authors"].apply(len)
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+    max_display = int(author_counts.quantile(0.99)) + 1
+    ax.hist(
+        author_counts.clip(upper=max_display),
+        bins=range(1, max_display + 2),
+        color=PALETTE[2],
+        edgecolor="white",
+        alpha=0.85,
+        align="left",
+    )
+    ax.set_xlabel("Number of Authors")
+    ax.set_ylabel("Frequency")
+    ax.set_title("Authors per Paper")
+    ax.spines[["top", "right"]].set_visible(False)
+    fig.tight_layout()
+    _savefig(fig, output_dir / "authors_per_paper.png")
+
+
+def plot_publication_timeline(df: pd.DataFrame, output_dir: Path) -> None:
+    """Monthly publication counts over time."""
+    dates = pd.to_datetime(df["published"], errors="coerce").dropna()
+    monthly = dates.dt.to_period("M").value_counts().sort_index()
+
+    fig, ax = plt.subplots(figsize=(10, 5))
+    ax.bar(
+        range(len(monthly)),
+        monthly.values,
+        color=PALETTE[1],
+        edgecolor="white",
+        width=1.0,
+    )
+    # Show a subset of tick labels to avoid crowding.
+    step = max(1, len(monthly) // 12)
+    tick_indices = list(range(0, len(monthly), step))
+    ax.set_xticks(tick_indices)
+    ax.set_xticklabels(
+        [str(monthly.index[i]) for i in tick_indices],
+        rotation=45,
+        ha="right",
+        fontsize=8,
+    )
+    ax.set_xlabel("Month")
+    ax.set_ylabel("Number of Papers")
+    ax.set_title("Publication Timeline (Monthly)")
+    ax.spines[["top", "right"]].set_visible(False)
+    fig.tight_layout()
+    _savefig(fig, output_dir / "publication_timeline.png")
+
+
+def plot_top_terms_heatmap(
+    terms_by_cat: dict[str, list[tuple[str, float]]],
+    output_dir: Path,
+    top_n: int = 10,
+) -> None:
+    """Heatmap-style visualisation of top TF-IDF terms across categories."""
+    # Gather the union of top terms across all categories.
+    all_terms: list[str] = []
+    for cat in sorted(terms_by_cat):
+        for term, _ in terms_by_cat[cat][:top_n]:
+            if term not in all_terms:
+                all_terms.append(term)
+
+    cats = sorted(terms_by_cat.keys())
+    matrix = np.zeros((len(all_terms), len(cats)))
+    for j, cat in enumerate(cats):
+        term_map = dict(terms_by_cat[cat])
+        for i, term in enumerate(all_terms):
+            matrix[i, j] = term_map.get(term, 0.0)
+
+    fig, ax = plt.subplots(figsize=(10, max(6, 0.35 * len(all_terms))))
+    im = ax.imshow(matrix, aspect="auto", cmap="YlOrRd", interpolation="nearest")
+    ax.set_xticks(range(len(cats)))
+    ax.set_xticklabels(cats, fontsize=9)
+    ax.set_yticks(range(len(all_terms)))
+    ax.set_yticklabels(all_terms, fontsize=8)
+    ax.set_title("Top TF-IDF Terms by Category")
+    fig.colorbar(im, ax=ax, label="Mean TF-IDF Score", shrink=0.6)
+    fig.tight_layout()
+    _savefig(fig, output_dir / "tfidf_terms_heatmap.png")
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Exploratory Data Analysis for the CS/ML Academic Papers Dataset.",
+    )
+    parser.add_argument(
+        "--data-dir",
+        type=str,
+        default=str(DATA_DIR),
+        help=f"Local data directory (default: {DATA_DIR}).",
+    )
+    parser.add_argument(
+        "--from-hub",
+        type=str,
+        default=None,
+        help="Load the dataset from a HuggingFace Hub repo instead of locally.",
+    )
+    parser.add_argument(
+        "--plots-dir",
+        type=str,
+        default=str(PLOTS_DIR),
+        help=f"Directory for saved plots (default: {PLOTS_DIR}).",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable debug logging.",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(asctime)s  %(levelname)-8s  %(name)s  %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    # ------------------------------------------------------------------
+    # 1. Load data
+    # ------------------------------------------------------------------
+    if args.from_hub:
+        LOG.info("Loading dataset from HuggingFace Hub: %s", args.from_hub)
+        df = load_hub(args.from_hub)
+    else:
+        LOG.info("Loading dataset from local directory: %s", args.data_dir)
+        df = load_local(Path(args.data_dir))
+
+    LOG.info("Loaded %d papers.", len(df))
+
+    # ------------------------------------------------------------------
+    # 2. Summary statistics
+    # ------------------------------------------------------------------
+    print_summary(df)
+
+    # ------------------------------------------------------------------
+    # 3. TF-IDF keyword extraction
+    # ------------------------------------------------------------------
+    LOG.info("Computing TF-IDF top terms per category ...")
+    terms_by_cat = top_tfidf_terms(df)
+    print_top_terms(terms_by_cat)
+
+    # ------------------------------------------------------------------
+    # 4. Visualisations
+    # ------------------------------------------------------------------
+    plots_dir = Path(args.plots_dir)
+    plots_dir.mkdir(parents=True, exist_ok=True)
+    LOG.info("Generating visualisations -> %s", plots_dir)
+
+    plot_category_distribution(df, plots_dir)
+    plot_abstract_length_histogram(df, plots_dir)
+    plot_abstract_length_by_category(df, plots_dir)
+    plot_authors_per_paper(df, plots_dir)
+    plot_publication_timeline(df, plots_dir)
+
+    if terms_by_cat:
+        plot_top_terms_heatmap(terms_by_cat, plots_dir)
+
+    LOG.info("All plots saved to %s", plots_dir)
+    print(f"Visualisations saved to: {plots_dir}")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,7 @@
+datasets>=2.14.0
+arxiv>=2.1.0
+pandas>=2.0.0
+matplotlib>=3.7.0
+scikit-learn>=1.3.0
+huggingface_hub>=0.17.0
+tqdm>=4.65.0