huggingface-paper-publisher

Publier et gérer des articles de recherche sur Hugging Face Hub. Prend en charge la création de pages d'articles, la liaison d'articles à des modèles/ensembles de données, la revendication de paternité et la génération d'articles de recherche professionnels basés sur Markdown.

npx skills add https://github.com/huggingface/skills --skill huggingface-paper-publisher

Vue d'ensemble

Cette compétence fournit des outils complets pour que les ingénieurs IA et les chercheurs publient, gèrent et lient des articles de recherche sur le Hugging Face Hub. Elle rationalise le flux de travail de la création à la publication, y compris l'intégration avec arXiv, la liaison modèles/ensembles de données et la gestion de l'auteur.

Intégration avec l'écosystème HF

  • Paper Pages : Indexer et découvrir des articles sur Hugging Face Hub
  • Intégration arXiv : Indexation automatique des articles à partir des ID arXiv
  • Liaison Modèles/Ensembles de données : Connecter les articles aux artefacts pertinents via les métadonnées
  • Vérification de l'auteur : Réclamer et vérifier l'auteur d'un article
  • Modèle d'article de recherche : Générer des articles scientifiques professionnels et modernes

Version

1.0.0

Dépendances

Le script inclus utilise les dépendances en ligne PEP 723. Préférez uv run à la configuration manuelle de l'environnement.

  • huggingface_hub>=0.26.0
  • pyyaml>=6.0.3
  • requests>=2.32.5
  • markdown>=3.5.0
  • python-dotenv>=1.2.1

Capacités principales

1. Gestion des pages d'articles

  • Indexer les articles : Ajouter des articles à Hugging Face à partir d'arXiv
  • Réclamer l'auteur : Vérifier et réclamer l'auteur sur les articles publiés
  • Gérer la visibilité : Contrôler quels articles apparaissent sur votre profil
  • Découvrir les articles : Trouver et explorer les articles dans l'écosystème HF

2. Lier les articles aux artefacts

  • Cartes de modèle : Ajouter les citations d'articles aux métadonnées du modèle
  • Cartes d'ensemble de données : Lier les articles aux ensembles de données via README
  • Balisage automatique : Le Hub génère automatiquement les balises arxiv:<PAPER_ID>
  • Gestion des citations : Maintenir l'attribution et les références appropriées

3. Création d'articles de recherche

  • Modèles Markdown : Générer un formatage professionnel des articles
  • Design moderne : Mises en page d'articles de recherche propres et lisibles
  • Table des matières dynamique : Génération automatique de la table des matières
  • Structure des sections : Organisation standard des articles scientifiques
  • Mathématiques LaTeX : Support des équations et de la notation technique

4. Gestion des métadonnées

  • Préambule YAML : Métadonnées appropriées de cartes de modèle/ensemble de données
  • Suivi des citations : Maintenir les références d'articles dans les référentiels
  • Contrôle des versions : Suivre les mises à jour et révisions des articles
  • Support multi-articles : Lier plusieurs articles à des artefacts uniques

Instructions d'utilisation

La compétence inclut des scripts Python dans scripts/ pour les opérations de publication d'articles.

Prérequis

  • Exécutez les scripts avec uv run (les dépendances sont résolues à partir de l'en-tête du script)
  • Définir la variable d'environnement HF_TOKEN avec un jeton ayant accès en écriture

Tous les chemins sont relatifs au répertoire contenant ce fichier SKILL.md. Avant d'exécuter un script, d'abord cd vers ce répertoire ou utilisez le chemin complet.

Méthode 1 : Indexer un article à partir d'arXiv

Ajouter un article à Hugging Face Paper Pages à partir d'arXiv.

Utilisation basique :

uv run scripts/paper_manager.py index \
  --arxiv-id "2301.12345"

Vérifier si l'article existe :

uv run scripts/paper_manager.py check \
  --arxiv-id "2301.12345"

Accès direct par URL : Vous pouvez également visiter https://huggingface.co/papers/{arxiv-id} directement pour indexer un article.

Méthode 2 : Lier un article à un modèle/ensemble de données

Ajouter des références d'articles au README du modèle ou de l'ensemble de données avec les métadonnées YAML appropriées.

Ajouter à la carte de modèle :

uv run scripts/paper_manager.py link \
  --repo-id "username/model-name" \
  --repo-type "model" \
  --arxiv-id "2301.12345"

Ajouter à la carte d'ensemble de données :

uv run scripts/paper_manager.py link \
  --repo-id "username/dataset-name" \
  --repo-type "dataset" \
  --arxiv-id "2301.12345"

Ajouter plusieurs articles :

uv run scripts/paper_manager.py link \
  --repo-id "username/model-name" \
  --repo-type "model" \
  --arxiv-ids "2301.12345,2302.67890,2303.11111"

Avec citation personnalisée :

uv run scripts/paper_manager.py link \
  --repo-id "username/model-name" \
  --repo-type "model" \
  --arxiv-id "2301.12345" \
  --citation "$(cat citation.txt)"

Fonctionnement de la liaison

Lorsque vous ajoutez un lien d'article arXiv au README d'un modèle ou d'un ensemble de données :

  1. Le Hub extrait l'ID arXiv du lien
  2. Une balise arxiv:<PAPER_ID> est automatiquement ajoutée au référentiel
  3. Les utilisateurs peuvent cliquer sur la balise pour afficher la page de l'article
  4. La page de l'article affiche tous les modèles/ensembles de données citant cet article
  5. Les articles sont découvrables via des filtres et une recherche

Méthode 3 : Réclamer l'auteur

Vérifier votre auteur sur les articles publiés sur Hugging Face.

Démarrer le processus de réclamation :

uv run scripts/paper_manager.py claim \
  --arxiv-id "2301.12345" \
  --email "your.email@institution.edu"

Processus manuel :

  1. Accédez à la page de votre article : https://huggingface.co/papers/{arxiv-id}
  2. Trouvez votre nom dans la liste des auteurs
  3. Cliquez sur votre nom et sélectionnez « Réclamer l'auteur »
  4. Attendez la vérification de l'équipe d'administration

Vérifier le statut de l'auteur :

uv run scripts/paper_manager.py check-authorship \
  --arxiv-id "2301.12345"

Méthode 4 : Gérer la visibilité des articles

Contrôler quels articles vérifiés apparaissent sur votre profil public.

Lister vos articles :

uv run scripts/paper_manager.py list-my-papers

Basculer la visibilité :

uv run scripts/paper_manager.py toggle-visibility \
  --arxiv-id "2301.12345" \
  --show true

Gérer dans les paramètres : Accédez aux paramètres de votre compte → Section Articles pour basculer « Afficher sur le profil » pour chaque article.

Méthode 5 : Créer un article de recherche

Générer un article de recherche professionnel basé sur markdown en utilisant des modèles modernes.

Créer à partir d'un modèle :

uv run scripts/paper_manager.py create \
  --template "standard" \
  --title "Your Paper Title" \
  --output "paper.md"

Modèles disponibles :

  • standard - Structure d'article scientifique traditionnel
  • modern - Format propre et convivial pour le web inspiré de Distill
  • arxiv - Formatage de style arXiv
  • ml-report - Rapport d'expérience d'apprentissage automatique

Générer un article complet :

uv run scripts/paper_manager.py create \
  --template "modern" \
  --title "Fine-Tuning Large Language Models with LoRA" \
  --authors "Jane Doe, John Smith" \
  --abstract "$(cat abstract.txt)" \
  --output "paper.md"

Convertir en HTML :

uv run scripts/paper_manager.py convert \
  --input "paper.md" \
  --output "paper.html" \
  --style "modern"

Structure du modèle d'article

Sections standard d'un article de recherche :

---
title: Your Paper Title
authors: Jane Doe, John Smith
affiliations: University X, Lab Y
date: 2025-01-15
arxiv: 2301.12345
tags: [machine-learning, nlp, fine-tuning]
---

# Abstract
Brief summary of the paper...

# 1. Introduction
Background and motivation...

# 2. Related Work
Previous research and context...

# 3. Methodology
Approach and implementation...

# 4. Experiments
Setup, datasets, and procedures...

# 5. Results
Findings and analysis...

# 6. Discussion
Interpretation and implications...

# 7. Conclusion
Summary and future work...

# References

Fonctionnalités du modèle moderne :

  • Table des matières dynamique
  • Design réactif pour l'affichage web
  • Mise en évidence de la syntaxe du code
  • Figures et graphiques interactifs
  • Rendu d'équations mathématiques (LaTeX)
  • Gestion des citations
  • Liaison d'affiliation d'auteur

Référence des commandes

Indexer un article :

uv run scripts/paper_manager.py index --arxiv-id "2301.12345"

Lier au référentiel :

uv run scripts/paper_manager.py link \
  --repo-id "username/repo-name" \
  --repo-type "model|dataset|space" \
  --arxiv-id "2301.12345" \
  [--citation "Full citation text"] \
  [--create-pr]

Réclamer l'auteur :

uv run scripts/paper_manager.py claim \
  --arxiv-id "2301.12345" \
  --email "your.email@edu"

Gérer la visibilité :

uv run scripts/paper_manager.py toggle-visibility \
  --arxiv-id "2301.12345" \
  --show true|false

Créer un article de recherche :

uv run scripts/paper_manager.py create \
  --template "standard|modern|arxiv|ml-report" \
  --title "Paper Title" \
  [--authors "Author1, Author2"] \
  [--abstract "Abstract text"] \
  [--output "filename.md"]

Convertir Markdown en HTML :

uv run scripts/paper_manager.py convert \
  --input "paper.md" \
  --output "paper.html" \
  [--style "modern|classic"]

Vérifier le statut de l'article :

uv run scripts/paper_manager.py check --arxiv-id "2301.12345"

Lister vos articles :

uv run scripts/paper_manager.py list-my-papers

Rechercher des articles :

uv run scripts/paper_manager.py search --query "transformer attention"

Format des métadonnées YAML

Lors de la liaison d'articles à des modèles ou des ensembles de données, le préambule YAML approprié est requis :

Exemple de carte de modèle :

---
language:
  - en
license: apache-2.0
tags:
  - text-generation
  - transformers
  - llm
library_name: transformers
---

# Model Name

This model is based on the approach described in [Our Paper](https://arxiv.org/abs/2301.12345).

## Citation

```bibtex
@article{doe2023paper,
  title={Your Paper Title},
  author={Doe, Jane and Smith, John},
  journal={arXiv preprint arXiv:2301.12345},
  year={2023}
}

**Exemple de carte d'ensemble de données :**
```yaml
---
language:
  - en
license: cc-by-4.0
task_categories:
  - text-generation
  - question-answering
size_categories:
  - 10K<n<100K
---

# Dataset Name

Dataset introduced in [Our Paper](https://arxiv.org/abs/2301.12345).

For more details, see the [paper page](https://huggingface.co/papers/2301.12345).

Le Hub extrait automatiquement les ID arXiv de ces liens et crée les balises arxiv:2301.12345.

Exemples d'intégration

Flux de travail 1 : Publier une nouvelle recherche

# 1. Créer un article de recherche
uv run scripts/paper_manager.py create \
  --template "modern" \
  --title "Novel Fine-Tuning Approach" \
  --output "paper.md"

# 2. Éditer paper.md avec votre contenu

# 3. Soumettre à arXiv (processus externe)
# Télécharger vers arxiv.org, obtenir l'ID arXiv

# 4. Indexer sur Hugging Face
uv run scripts/paper_manager.py index --arxiv-id "2301.12345"

# 5. Lier à votre modèle
uv run scripts/paper_manager.py link \
  --repo-id "your-username/your-model" \
  --repo-type "model" \
  --arxiv-id "2301.12345"

# 6. Réclamer l'auteur
uv run scripts/paper_manager.py claim \
  --arxiv-id "2301.12345" \
  --email "your.email@edu"

Flux de travail 2 : Lier un article existant

# 1. Vérifier si l'article existe
uv run scripts/paper_manager.py check --arxiv-id "2301.12345"

# 2. Indexer si nécessaire
uv run scripts/paper_manager.py index --arxiv-id "2301.12345"

# 3. Lier à plusieurs référentiels
uv run scripts/paper_manager.py link \
  --repo-id "username/model-v1" \
  --repo-type "model" \
  --arxiv-id "2301.12345"

uv run scripts/paper_manager.py link \
  --repo-id "username/training-data" \
  --repo-type "dataset" \
  --arxiv-id "2301.12345"

uv run scripts/paper_manager.py link \
  --repo-id "username/demo-space" \
  --repo-type "space" \
  --arxiv-id "2301.12345"

Flux de travail 3 : Mettre à jour le modèle avec référence d'article

# 1. Obtenir le README actuel
hf download username/model-name README.md

# 2. Ajouter le lien d'article
uv run scripts/paper_manager.py link \
  --repo-id "username/model-name" \
  --repo-type "model" \
  --arxiv-id "2301.12345" \
  --citation "Full citation for the paper"

# Le script va :
# - Ajouter les métadonnées YAML si manquantes
# - Insérer le lien arXiv dans le README
# - Ajouter une citation formatée
# - Préserver le contenu existant

Bonnes pratiques

  1. Indexation des articles

    • Indexer les articles dès qu'ils sont publiés sur arXiv
    • Inclure les informations complètes de citation dans les cartes de modèle/ensemble de données
    • Utiliser des références d'article cohérentes dans tous les référentiels associés

  2. Gestion des métadonnées

    • Ajouter un préambule YAML à tous les modèles/cartes d'ensemble de données
    • Inclure les informations de licence appropriées
    • Baliser avec les catégories de tâches et les domaines pertinents

  3. Auteur

    • Réclamer l'auteur sur les articles où vous êtes listés comme auteur
    • Utiliser les adresses e-mail institutionnelles pour la vérification
    • Garder les paramètres de visibilité des articles à jour

  4. Liaison de référentiel

    • Lier les articles à tous les modèles, ensembles de données et Spaces pertinents
    • Inclure le contexte de l'article dans les descriptions du README
    • Ajouter les citations BibTeX pour une référence facile

  5. Articles de recherche

    • Utiliser les modèles de manière cohérente au sein des projets
    • Inclure les liens de code et de données dans les articles
    • Générer des versions HTML conviviales pour le web à des fins de partage

Utilisation avancée

Articles de liaison par lot :

# Lier plusieurs articles à un seul référentiel
for arxiv_id in "2301.12345" "2302.67890" "2303.11111"; do
  uv run scripts/paper_manager.py link \
    --repo-id "username/model-name" \
    --repo-type "model" \
    --arxiv-id "$arxiv_id"
done

Extraire les informations d'article :

# Obtenir les métadonnées d'article à partir d'arXiv
uv run scripts/paper_manager.py info \
  --arxiv-id "2301.12345" \
  --format "json"

Générer une citation :

# Créer une citation BibTeX
uv run scripts/paper_manager.py citation \
  --arxiv-id "2301.12345" \
  --format "bibtex"

Valider les liens :

# Vérifier tous les liens d'articles dans un référentiel
uv run scripts/paper_manager.py validate \
  --repo-id "username/model-name" \
  --repo-type "model"

Gestion des erreurs

  • Article non trouvé : L'ID arXiv n'existe pas ou n'est pas encore indexé
  • Permission refusée : HF_TOKEN n'a pas d'accès en écriture au référentiel
  • YAML invalide : Métadonnées malformées dans le préambule du README
  • Échec de l'auteur : L'e-mail ne correspond pas aux enregistrements d'auteur de l'article
  • Déjà réclamé : Un autre utilisateur a réclamé l'auteur
  • Limitation de débit : Trop de demandes d'API en peu de temps

Dépannage

Problème : « Article non trouvé sur Hugging Face »

  • Solution : Visitez hf.co/papers/{arxiv-id} pour déclencher l'indexation

Problème : « Réclamation d'auteur non vérifiée »

  • Solution : Attendez l'examen de l'administration ou contactez le support HF avec preuve

Problème : « La balise arXiv n'apparaît pas »

  • Solution : Assurez-vous que le README inclut le format d'URL arXiv approprié

Problème : « Impossible de lier au référentiel »

  • Solution : Vérifiez que HF_TOKEN a les permissions d'écriture

Problème : « Erreurs de rendu de modèle »

  • Solution : Vérifiez la syntaxe markdown et le format du préambule YAML

Ressources et références

Intégration avec le modèle de recherche de tfrere

Cette compétence complète le modèle d'article de recherche de tfrere en fournissant :

  • Flux de travail d'indexation d'article automatisés
  • Capacités de liaison de référentiel
  • Outils de gestion des métadonnées
  • Utilitaires de génération de citations

Vous pouvez utiliser le modèle de tfrere pour l'écriture, puis utiliser cette compétence pour publier et lier l'article sur Hugging Face Hub.

Modèles courants

Modèle 1 : Nouvelle publication de recherche

# Écrire → Publier → Indexer → Lier
uv run scripts/paper_manager.py create --template modern --output paper.md
# (Soumettre à arXiv)
uv run scripts/paper_manager.py index --arxiv-id "2301.12345"
uv run scripts/paper_manager.py link --repo-id "user/model" --arxiv-id "2301.12345"

Modèle 2 : Découverte d'article existant

# Rechercher → Vérifier → Lier
uv run scripts/paper_manager.py search --query "transformers"
uv run scripts/paper_manager.py check --arxiv-id "2301.12345"
uv run scripts/paper_manager.py link --repo-id "user/model" --arxiv-id "2301.12345"

Modèle 3 : Gestion du portefeuille d'auteur

# Réclamer → Vérifier → Organiser
uv run scripts/paper_manager.py claim --arxiv-id "2301.12345"
uv run scripts/paper_manager.py list-my-papers
uv run scripts/paper_manager.py toggle-visibility --arxiv-id "2301.12345" --show true

Intégration API

Exemple de script Python :

from scripts.paper_manager import PaperManager

pm = PaperManager(hf_token="your_token")

# Indexer un article
pm.index_paper("2301.12345")

# Lier au modèle
pm.link_paper(
    repo_id="username/model",
    repo_type="model",
    arxiv_id="2301.12345",
    citation="Full citation text"
)

# Vérifier le statut
status = pm.check_paper("2301.12345")
print(status)

Améliorations futures

Fonctionnalités prévues pour les versions futures :

  • Support des articles non-arXiv (actes de conférence, journaux)
  • Formatage automatique des citations à partir de DOI
  • Outils de comparaison et de versioning d'articles
  • Fonctionnalités d'écriture collaborative d'articles
  • Intégration aux flux de travail LaTeX
  • Extraction automatique de figures et de tableaux
  • Suivi des métriques et de l'impact des articles