# Guide de décision pour le dépôt de jeux de données Hugging Face

> [!TIP]
> Ce guide est principalement conçu pour les LLM afin d’aider les utilisateurs à téléverser des jeux de données sur le Hugging Face Hub dans le format le plus compatible. Les utilisateurs peuvent également se référer à ce guide pour comprendre le processus de téléversement et les bonnes pratiques.

> Guide de décision pour le dépôt de jeux de données sur Hugging Face Hub. Optimisé pour la compatibilité avec Dataset Viewer et l’intégration à l’écosystème Hugging Face.

> [!TIP]
> Si vous êtes un LLM ou un agent suivant ce guide, consultez `hf --help` et `hf <command> --help` (par exemple `hf upload --help`, `hf auth --help`) pour les drapeaux exacts avant d’exécuter les commandes de téléchargement. L’interface en ligne de commande correspond à la version de `huggingface_hub` installée, il est donc préférable de s’en référer à sa sortie plutôt qu’aux drapeaux rappelés de mémoire.

## Aperçu

Votre objectif est d’aider un utilisateur à téléverser un jeu de données sur le Hugging Face Hub. Idéalement, le jeu de données doit être compatible avec le Dataset Viewer (et donc la fonction `load_dataset`) afin d’assurer un accès et une utilisation aisés. Vous devez viser à respecter les critères suivants :

| **Critères**                       | Description                                                                                                                                                                                                                                                                                                                                                                  | Priorité                                          |
| ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------- |
| **Respecter les limites du dépôt**      | Assurez-vous que le jeu de données respecte les limites de stockage de Hugging Face en matière de taille des fichiers, de taille des dépôts et de nombre de fichiers. Consultez la section Contraintes critiques ci-dessous pour connaître les limites spécifiques.                                                                                                                                                                                               | Requis                                          |
| **Utiliser des formats compatibles avec le hub**     | Utilisez le format Parquet lorsque c’est possible (meilleure compression, typage riche, prise en charge des grands jeux de données). Pour les jeux de données plus petits (<quelques Go), JSON/JSONL ou CSV sont acceptables. Les fichiers bruts fonctionnent bien pour les images/audio dans les petits jeux de données, tout en respectant les limites du dépôt. Utilisez WebDataset (.tar) pour les grandes collections de médias. Les formats spécifiques au domaine peuvent être utilisés lorsque la conversion est irréalisable. | Souhaité                                           |
| **Compatibilité avec le Dataset Viewer**   | Structurez les données pour travailler avec le Dataset Viewer automatique, permettant l’aperçu et l’exploration aisée. Cela implique généralement d’utiliser des formats pris en charge et une organisation de fichiers appropriée. Les étapes de validation sont fournies plus loin dans ce guide.                                                                                                                                               | Souhaité                                           |
| **Organiser les données de manière judicieuse**         | Utilisez des structures de dossiers logiques conformes aux conventions du Hub (par exemple, des partitions train/test). Les fichiers de configuration peuvent être utilisés pour définir différentes configurations du jeu de données. Cela facilite à la fois la compréhension humaine et le chargement automatique des données.                                                                                                                                             | Souhaité                                           |
| **Utiliser les Features appropriées**       | Lors de l'utilisation de la bibliothèque datasets, spécifiez les types de fonctionnalités corrects (par exemple, Image(), Audio(), ClassLabel()) pour garantir un traitement approprié des données et le bon fonctionnement du visualiseur. Cela permet des optimisations et des aperçus spécifiques au type.                                                                                                                                                        | Requis (lors de l'utilisation de la bibliothèque datasets)            |
| **Documenter des jeux de données non standard** | Si la conversion vers des formats compatibles avec le hub est impossible et qu’il est nécessaire d’utiliser des formats personnalisés, veillez à respecter strictement les limites du dépôt et fournissez une documentation claire sur la manière de télécharger et de charger le jeu de données. Incluez des exemples d’utilisation ainsi que toute exigence particulière.                                                                                                          | Requis (lorsque la bibliothèque datasets n'est pas compatible) |

## Travailler sans accès aux fichiers

Lorsque vous n'avez pas accès direct aux fichiers de l'utilisateur (par exemple, via une interface web), demandez-lui d'exécuter ces commandes pour comprendre son jeu de données :

**Structure du jeu de données** :

```bash
# Show directory tree (install with: pip install tree or brew install tree)
tree -L 3 --filelimit 20

# Alternative without tree:
find . -type f -name "*.csv" -o -name "*.json" -o -name "*.parquet" | head -20
```

**Vérifier les tailles de fichiers** :

```bash
# Total dataset size
du -sh .

# Individual file sizes
ls -lh data/
```

**Aperçu du format des données** :

```bash
# First few lines of CSV/JSON
head -n 5 data/train.csv

# Check image folder structure
ls -la images/ | head -10
```

**Nombre rapide de fichiers** :

```bash
# Count files by type
find . -name "*.jpg" | wc -l
```

## Contraintes critiques

**Limites de stockage** :

Si ces valeurs diffèrent de [storage-limits](https://huggingface.co/docs/hub/storage-limits#repository-limitations-and-recommendations), storage-limits fait foi.

```yaml
# Machine-readable Hub limits
hub_limits:
  max_file_size_gb: 500 # absolute hard stop per file
  recommended_file_size_gb: 200 # split larger files into chunks below this
  max_files_per_folder: 10000 # Git performance threshold
  max_files_per_repo: 100000 # recommended maximum; keep well below
  viewer_row_size_mb: 2 # approximate per-row viewer limit
  # No per-repo size limit: repo size counts against the account's storage quota
```

**Résumé lisible par un humain** :

- Par fichier : 500 Go max, <200 Go recommandés
- Par dossier : <10k fichiers
- Par dépôt : <100k fichiers recommandés
- Le stockage du compte (public et privé) dépend de l’abonnement : voir [plans de stockage](https://huggingface.co/docs/hub/storage-limits#storage-plans)

Consultez https://huggingface.co/docs/hub/storage-limits pour les offres de stockage actuelles et les recommandations de dépôts.

## Référence rapide par type de données

| Vos données                           | Approche recommandée                                                                                         | Commande rapide                                                                                    |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------ |
| **Fichiers CSV/JSON**                  | Utiliser les chargeurs intégrés (gère toute taille via le mappage mémoire)                                                   | `load_dataset("csv", data_files="data.csv").push_to_hub("username/dataset")`                     |
| **Images dans des dossiers**               | Utilisez [imagefolder](https://huggingface.co/docs/datasets/en/image_load) pour la détection automatique des classes          | `load_dataset("imagefolder", data_dir="./images").push_to_hub("username/dataset")`               |
| **Fichiers audio**                     | Utilisez [audiofolder](https://huggingface.co/docs/datasets/en/audio_load) pour une organisation automatique             | `load_dataset("audiofolder", data_dir="./audio").push_to_hub("username/dataset")`                |
| **Fichiers vidéo**                     | Utilisez [videofolder](https://huggingface.co/docs/datasets/en/video_load#videofolder) pour une organisation automatique | `load_dataset("videofolder", data_dir="./videos").push_to_hub("username/dataset")`               |
| **Documents PDF**                   | Utilisez [pdffolder](https://huggingface.co/docs/datasets/en/document_dataset#pdffolder) pour l'extraction de texte      | `load_dataset("pdffolder", data_dir="./pdfs").push_to_hub("username/dataset")`                   |
| **Très grands jeux de données (100 Go et plus)**    | Utilisez `max_shard_size` pour contrôler l'utilisation de la mémoire                                                                 | `dataset.push_to_hub("username/dataset", max_shard_size="5GB")`                                  |
| **Nombreux fichiers / répertoires (>10k)** | Utilisez `upload_folder`/`hf upload` (gère les téléversements de fichiers volumineux ou nombreux)                                                             | `hf upload username/dataset ./data --repo-type=dataset` |
| **Diffusion de médias volumineux**           | Format WebDataset pour un streaming efficace                                                                    | Créer des shards .tar, puis `hf upload`                                                 |
| **Données scientifiques (HDF5, NetCDF)**  | Conversion en Parquet avec des fonctionnalités de type Array                                                                       | Voir la section [Scientific Data](#scientific-data)                                                  |
| **Formats personnalisés/proprio**      | Documentez soigneusement si la conversion est impossible                                                                 | `hf upload` avec un README complet                                                |

## Workflow de téléversement

0. ✓ **Récupérer les informations du jeu de données** (si nécessaire) :

   - Quel type de données ? (images, texte, audio, CSV, etc.)
   - Comment est-il organisé ? (structure de dossiers, fichier unique, plusieurs fichiers)
   - Quelle est la taille approximative ?
   - Sous quel format sont les fichiers ?
   - Des exigences particulières ? (par exemple, streaming, accès privé)
   - Vérifiez la présence de fichiers README ou de documentation existants qui décrivent le jeu de données

1. ✓ **S'authentifier** :
   - CLI : `hf auth login`
   - Ou utilisez le jeton : `HfApi(token="hf_...")` ou définissez la variable d'environnement `HF_TOKEN`
2. ✓ **Identifier votre type de données** : Consultez le tableau [Référence rapide](#quick-reference-by-data-type) ci-dessus
3. ✓ **Choisir la méthode de téléversement** :

   - **Petits fichiers (<1 Go) au format compatible avec le Hub** : Vous pouvez utiliser l'[interface utilisateur du Hub](https://huggingface.co/new-dataset) pour des téléversements rapides
   - **Chargeur intégré disponible** : utilisez le chargeur + `push_to_hub()` (voir le tableau de référence rapide)
   - **Jeux de données volumineux ou nombreux fichiers** : utilisez `upload_folder` / `hf upload` qui gèrent les téléversements de grande taille (multi-commit automatique, reprise possible).
   - **Formats personnalisés** : convertir au format compatible avec le hub si possible, sinon documenter de manière exhaustive

4. ✓ **Tester localement** (si vous utilisez le chargeur intégré) :

   ```python
   # Validate your dataset loads correctly before uploading
   dataset = load_dataset("loader_name", data_dir="./your_data")
   print(dataset)
   ```

5. ✓ **Téléverser sur le Hub** :

   ```python
   # Basic upload
   dataset.push_to_hub("username/dataset-name")

   # With options for large datasets
   dataset.push_to_hub(
       "username/dataset-name",
       max_shard_size="5GB",  # Control memory usage
       private=True  # For private datasets
   )
   ```

6. ✓ **Vérifier votre téléversement** :
   - Vérifier le Dataset Viewer : `https://huggingface.co/datasets/username/dataset-name`
   - Test de chargement : `load_dataset("username/dataset-name")`
   - Si le visualiseur affiche des erreurs, consultez la section [Dépannage](#common-issues--solutions)

## Modèles de conversion courants

Lorsque les chargeurs intégrés ne correspondent pas à la structure de vos données, utilisez la bibliothèque datasets comme couche de compatibilité. Convertissez vos données en objet Dataset, puis utilisez `push_to_hub()` pour une flexibilité maximale et une compatibilité avec le Dataset Viewer.

### Depuis des DataFrames

Si vous avez déjà vos données fonctionnelles dans pandas, polars ou d'autres bibliothèques de dataframes, vous pouvez convertir directement :

```python
# From pandas DataFrame
import pandas as pd
from datasets import Dataset

df = pd.read_csv("your_data.csv")
dataset = Dataset.from_pandas(df)
dataset.push_to_hub("username/dataset-name")

# From polars DataFrame (direct method)
import polars as pl
from datasets import Dataset

df = pl.read_csv("your_data.csv")
dataset = Dataset.from_polars(df)  # Direct conversion
dataset.push_to_hub("username/dataset-name")

# From PyArrow Table (useful for scientific data)
import pyarrow as pa
from datasets import Dataset

# If you have a PyArrow table
table = pa.table({'data': [1, 2, 3], 'labels': ['a', 'b', 'c']})
dataset = Dataset(table)
dataset.push_to_hub("username/dataset-name")

# For Spark/Dask dataframes, see https://huggingface.co/docs/hub/datasets-libraries
```

## Conversion de format personnalisé

Lorsque les chargeurs intégrés ne correspondent pas au format de vos données, convertissez-les en objets Dataset en suivant ces principes :

### Principes de conception

**1. Privilégier les structures larges/plates plutôt que les jointures**

- Dénormaliser les données relationnelles en lignes uniques pour une meilleure utilisabilité
- Inclure toutes les informations pertinentes dans chaque exemple
- Privilégiez des données plus volumineuses mais plus exploitables - l'infrastructure de Hugging Face utilise une déduplication avancée (XetHub) et des optimisations Parquet pour gérer efficacement la redondance

**2. Utiliser des configurations pour les variations logiques des jeux de données**

- En plus des partitions train/test/val, utilisez des configurations pour différents sous-ensembles ou vues de vos données
- Chaque configuration peut avoir des fonctionnalités ou une organisation des données différentes
- Exemple : configurations spécifiques à une langue, vues spécifiques à une tâche ou modalités de données

### Méthodes de conversion

**Petits jeux de données (qui tiennent en mémoire) - utilisez `Dataset.from_dict()`** :

```python
# Parse your custom format into a dictionary
data_dict = {
    "text": ["example1", "example2"],
    "label": ["positive", "negative"],
    "score": [0.9, 0.2]
}

# Create dataset with appropriate features
from datasets import Dataset, Features, Value, ClassLabel
features = Features({
    'text': Value('string'),
    'label': ClassLabel(names=['negative', 'positive']),
    'score': Value('float32')
})

dataset = Dataset.from_dict(data_dict, features=features)
dataset.push_to_hub("username/dataset")
```

**Jeux de données volumineux (efficace en mémoire) - utilisez `Dataset.from_generator()`** :

```python
def data_generator():
    # Parse your custom format progressively
    for item in parse_large_file("data.custom"):
        yield {
            "text": item["content"],
            "label": item["category"],
            "embedding": item["vector"]
        }

# Specify features for Dataset Viewer compatibility
from datasets import Features, Value, ClassLabel, List
features = Features({
    'text': Value('string'),
    'label': ClassLabel(names=['cat1', 'cat2', 'cat3']),
    'embedding': List(feature=Value('float32'), length=768)
})

dataset = Dataset.from_generator(data_generator, features=features)
dataset.push_to_hub("username/dataset", max_shard_size="1GB")
```

**Astuce** : Pour les grands jeux de données, testez d'abord avec un sous-ensemble en ajoutant une limite à votre générateur ou en utilisant `.select(range(100))` après la création.

### Utilisation des configurations pour les variations de jeu de données

```python
# Push different configurations of your dataset
dataset_en = Dataset.from_dict(english_data, features=features)
dataset_en.push_to_hub("username/multilingual-dataset", config_name="english")

dataset_fr = Dataset.from_dict(french_data, features=features)
dataset_fr.push_to_hub("username/multilingual-dataset", config_name="french")

# Users can then load specific configs
dataset = load_dataset("username/multilingual-dataset", "english")
```

### Exemples multi-modaux

**Texte + Audio (reconnaissance vocale)** :

```python
def speech_generator():
    for audio_file in Path("audio/").glob("*.wav"):
        transcript_file = audio_file.with_suffix(".txt")
        yield {
            "audio": str(audio_file),
            "text": transcript_file.read_text().strip(),
            "speaker_id": audio_file.stem.split("_")[0]
        }

features = Features({
    'audio': Audio(sampling_rate=16000),
    'text': Value('string'),
    'speaker_id': Value('string')
})

dataset = Dataset.from_generator(speech_generator, features=features)
dataset.push_to_hub("username/speech-dataset")
```

**Plusieurs images par exemple** :

```python
# Before/after images, medical imaging, etc.
data = {
    "image_before": ["img1_before.jpg", "img2_before.jpg"],
    "image_after": ["img1_after.jpg", "img2_after.jpg"],
    "treatment": ["method_A", "method_B"]
}

features = Features({
    'image_before': Image(),
    'image_after': Image(),
    'treatment': ClassLabel(names=['method_A', 'method_B'])
})

dataset = Dataset.from_dict(data, features=features)
dataset.push_to_hub("username/before-after-images")
```

**Note** : Pour les données texte + images, envisagez d'utiliser ImageFolder avec metadata.csv, qui gère cela automatiquement.

## Fonctionnalités essentielles

Les fonctionnalités définissent le schéma et les types de données des colonnes de votre jeu de données. Spécifier les fonctionnalités correctes garantit :

- Gestion appropriée des données et conversion de types
- Fonctionnalités du Dataset Viewer (par exemple, aperçus d'images/audios)
- Stockage et chargement efficaces
- Documentation claire de votre structure de données

Pour la documentation complète des fonctionnalités, voir : [Fonctionnalités des jeux de données](https://huggingface.co/docs/datasets/about_dataset_features)

### Aperçu des types de fonctionnalités

**Types de base** :

- `Value` : valeurs scalaires - `string`, `int64`, `float32`, `bool`, `binary` et autres types numériques
- `ClassLabel` : Données catégorielles avec des classes nommées
- `Sequence` : Listes de n'importe quel type de fonction
- `LargeList` : pour les très grandes listes

**Types de médias** (activer les aperçus du Dataset Viewer) :

- `Image()` : Gère divers formats d’images et renvoie des objets PIL Image
- `Audio(sampling_rate=16000)` : Audio avec des données en tableau et un taux d'échantillonnage facultatif
- `Video()` : Fichiers vidéo
- `Pdf()` : documents PDF avec extraction de texte

**Types de tableaux** (pour les tenseurs/données scientifiques) :

- `Array2D`, `Array3D`, `Array4D`, `Array5D` : tableaux de longueur fixe ou variable
- Exemple : `Array2D(shape=(224, 224), dtype='float32')`
- La première dimension peut être `None` pour une longueur variable

**Types de traduction** :

- `Translation` : Pour les paires de traduction avec des langues fixes
- `TranslationVariableLanguages` : pour les traductions avec des paires de langues variables

**Note** : De nouveaux types de fonctionnalités sont ajoutés régulièrement. Consultez la documentation pour les dernières ajouts.

## Méthodes de téléversement

**Objets Dataset (utilisez push_to_hub)** : à utiliser lorsque vous avez chargé/converti des données à l'aide de la bibliothèque datasets

```python
dataset.push_to_hub("username/dataset", max_shard_size="5GB")
```

**Fichiers existants (utiliser `upload_folder` / `hf upload`)** : À utiliser lorsque vous disposez déjà de fichiers compatibles avec le hub (par exemple, des fichiers Parquet) préparés et organisés.

```python
from huggingface_hub import HfApi
api = HfApi()
api.upload_folder(folder_path="./data", repo_id="username/dataset", repo_type="dataset")
```

```bash
# Or from the CLI:
hf upload username/dataset ./data --repo-type=dataset
```

**Important** : avant de téléverser, vérifiez que les fichiers respectent les limites du dépôt :

- Vérifiez la structure des dossiers si vous avez accès aux fichiers : assurez-vous qu'aucun dossier ne contient plus de 10 000 fichiers
- Demandez à l'utilisateur de confirmer : « Vos fichiers sont-ils au format compatible avec le hub (Parquet/CSV/JSON) et organisés de manière appropriée ? »
- Pour les formats non standard, envisagez de convertir d'abord en objets Dataset pour garantir la compatibilité

## Validation

**Envisager une légère mise en forme** : si les données sont proches du format d’un chargeur intégré, suggérer des modifications mineures :

- Renommer les colonnes (par exemple, 'filename' → 'file_name' pour ImageFolder)
- Réorganiser les dossiers (par exemple, déplacer les images dans des sous-dossiers de classes)
- Renommer les fichiers pour correspondre aux motifs attendus (par exemple, 'data.csv' → 'train.csv')

**Avant l'envoi** :

- Testez localement : `load_dataset("imagefolder", data_dir="./data")`
- Vérifier que les fonctionnalités fonctionnent correctement :

  ```python
  # Test first example
  print(dataset[0])

  # For images: verify they load
  if 'image' in dataset.features:
      dataset[0]['image']  # Should return PIL Image

  # Check dataset size before upload
  print(f"Size: {len(dataset)} examples")
  ```

- Vérifier que metadata.csv contient la colonne file_name
- Vérifier les chemins relatifs, sans barres obliques initiales
- Vérifier qu'aucun dossier ne contient plus de 10 000 fichiers

**Après l'envoi** :

- Vérifier le visualiseur : `https://huggingface.co/datasets/username/dataset`
- Test de chargement : `load_dataset("username/dataset")`
- Vérifier les fonctionnalités conservées : `print(dataset.features)`

## Problèmes courants → Solutions

| Problème                      | Solution                             |
| -------------------------- | ------------------------------------ |
| "Repository introuvable"     | Exécutez `hf auth login`          |
| Erreurs de mémoire              | Utilisez `max_shard_size="500MB"`         |
| Le visionneuse de jeux de données ne fonctionne pas | Attendez 5 à 10 minutes, vérifiez la configuration dans README.md |
| Fichiers >200Go               | Séparer en fichiers plus petits             |
| "Fichier introuvable"           | Utiliser des chemins relatifs dans les métadonnées       |

## Configuration du Dataset Viewer

**Note** : Cette section s’adresse principalement aux jeux de données téléversés directement sur le Hub (via l’interface, `upload_folder` ou `hf upload`). Les jeux de données téléversés avec `push_to_hub()` configurent généralement le visualiseur automatiquement.

### Lorsque la détection automatique fonctionne

Le Dataset Viewer détecte automatiquement les structures standard :

- Fichiers nommés : `train.csv`, `test.json`, `validation.parquet`
- Répertoires nommés : `train/`, `test/`, `validation/`
- Séparez les noms par des délimiteurs : `test-data.csv` ✓ (pas `testdata.csv` ✗)

### Configuration manuelle

Pour les structures personnalisées, ajoutez du YAML à votre README.md :

```yaml
---
configs:
  - config_name: default # Required even for single config!
    data_files:
      - split: train
        path: "data/train/*.parquet"
      - split: test
        path: "data/test/*.parquet"
---
```

Exemple de configurations multiples :

```yaml
---
configs:
  - config_name: english
    data_files: "en/*.parquet"
  - config_name: french
    data_files: "fr/*.parquet"
---
```

### Problèmes courants du visualiseur

- **Aucun visualiseur après le téléversement** : Attendez 5 à 10 minutes pour le traitement
- **"Erreur de noms de configuration"** : ajouter le champ `config_name` (obligatoire !)
- **Fichiers non détectés** : Vérifiez les motifs de nommage (des délimiteurs sont nécessaires)
- **Visualiseur désactivé** : Supprimez `viewer: false` du YAML du README

## Modèles rapides

```python
# ImageFolder with metadata
dataset = load_dataset("imagefolder", data_dir="./images")
dataset.push_to_hub("username/dataset")

# Memory-efficient upload
dataset.push_to_hub("username/dataset", max_shard_size="500MB")

# Multiple CSV files
dataset = load_dataset('csv', data_files={'train': 'train.csv', 'test': 'test.csv'})
dataset.push_to_hub("username/dataset")
```

## Documentation

**Documentation principale** : [Ajouter des jeux de données](https://huggingface.co/docs/hub/datasets-adding) | [Visualiseur de jeux de données](https://huggingface.co/docs/hub/datasets-viewer) | [Limites de stockage](https://huggingface.co/docs/hub/storage-limits) | [Guide de téléversement](https://huggingface.co/docs/datasets/upload_dataset)

## Cartes de jeu de données

Rappelez aux utilisateurs d’ajouter une carte de jeu de données (README.md) avec :

- Description et utilisation du jeu de données
- Informations sur la licence
- Détails de la citation

Voir le [guide des fiches de jeu de données](https://huggingface.co/docs/hub/datasets-cards) pour plus de détails.

---

## Annexe : Cas particuliers

### Structure de WebDataset

Pour le streaming de grands jeux de données multimédias :

- Créer des shards tar de 1 à 5 Go
- Structure interne cohérente
- Téléverser avec `hf upload`

### Données scientifiques

- HDF5/NetCDF → Conversion en Parquet avec des fonctionnalités Array
- Séries temporelles → Array2D(shape=(None, n))
- Métadonnées complexes → Stocker sous forme de chaînes JSON

### Ressources de la communauté

Pour des formats très spécialisés ou sur mesure :

- Recherchez des jeux de données similaires sur le Hub : `https://huggingface.co/datasets`
- Demandez des conseils sur les [forums Hugging Face](https://discuss.huggingface.co/c/datasets/10)
- Rejoignez le [Discord Hugging Face](https://hf.co/join/discord) pour une aide en temps réel
- De nombreux formats spécifiques à un domaine ont déjà des exemples sur le Hub

