# Stockage cloud

## Hugging Face Datasets

Le Hugging Face Dataset Hub abrite une collection croissante de jeux de données couvrant une variété de domaines et de tâches.

C'est bien plus qu'un stockage cloud : le Dataset Hub est une plateforme qui offre le versionnage des données grâce à git, ainsi qu'un Dataset Viewer pour explorer les données, ce qui en fait un excellent endroit pour stocker des jeux de données prêts pour l'IA.

Ce guide montre comment importer des données depuis d'autres stockages cloud en utilisant les implémentations de systèmes de fichiers de `fsspec`.

## Buckets de stockage Hugging Face

Les Storage Buckets sont un type de dépôt sur le Hugging Face Hub offrant un stockage d’objets de type S3, propulsé par le backend de stockage Xet. Contrairement aux dépôts de données basés sur Git, les buckets ne sont pas versionnés et sont mutables, conçus pour des cas d’usage nécessitant un stockage simple et rapide, tels que les journaux, les artefacts intermédiaires ou tout grand ensemble de fichiers qui n’a pas besoin de contrôle de version.

## Importer des données depuis un stockage cloud

La plupart des fournisseurs de stockage cloud disposent d'une implémentation FileSystem de `fsspec`, ce qui est pratique pour importer des données depuis n'importe quel fournisseur cloud avec le même code. Cela est particulièrement utile pour publier des jeux de données sur Hugging Face.

Consultez le tableau ci-dessous pour quelques exemples de fournisseurs de stockage cloud pris en charge :

| Fournisseur de stockage     | Implémentation du système de fichiers                                     |
|----------------------|---------------------------------------------------------------|
| Amazon S3            | [s3fs](https://s3fs.readthedocs.io/en/latest/)                |
| Google Cloud Storage | [gcsfs](https://gcsfs.readthedocs.io/en/latest/)              |
| Azure Blob/DataLake  | [adlfs](https://github.com/fsspec/adlfs)                      |
| Oracle Cloud Storage | [ocifs](https://ocifs.readthedocs.io/en/latest/)              |

Ce guide vous montre comment importer des fichiers de données depuis n'importe quel stockage cloud et enregistrer un jeu de données sur Hugging Face.

Supposons que nous voulions publier un jeu de données sur Hugging Face à partir de fichiers Parquet stockés dans un stockage cloud.

Premièrement, instanciez votre système de fichiers de stockage cloud et listez les fichiers que vous souhaitez importer :

```python
>>> import fsspec
>>> fs = fsspec.filesystem("...")  # s3 / gcs / abfs / adl / oci / ...
>>> data_dir = "path/to/my/data/"
>>> pattern = "*.parquet"
>>> data_files = fs.glob(data_dir + pattern)
["path/to/my/data/0001.parquet", "path/to/my/data/0001.parquet", ...]
```

### Publier un jeu de données

Vous pouvez ensuite créer un jeu de données sur Hugging Face et importer les fichiers de données, en utilisant par exemple :

```python
>>> from huggingface_hub import create_repo, upload_folder
>>> from tqdm.auto import tqdm
>>> destination_dataset = "username/my-dataset"
>>> create_repo(destination_dataset, repo_type="dataset")
>>> batch_size = 100
>>> for data_files in batched(tqdm(fs.glob(data_dir + pattern)), batch_size):
...     with TemporaryDirectory() as tmp_dir:
...         tmp_files = [os.path.join(tmp_dir, x[len(data_dir):]) for x in data_files]
...         fs.download(data_files, tmp_files)
...         upload_folder(
...             repo_id=destination_dataset,
...             folder_path=tmp_dir,
...             repo_type="dataset",
...         )
```

Consultez la documentation de [huggingface_hub](https://huggingface.co/docs/huggingface_hub) sur le téléversement de fichiers [ici](https://huggingface.co/docs/huggingface_hub/en/guides/upload) si vous recherchez d'autres options de téléversement.

Enfin, vous pouvez maintenant charger le jeu de données à l'aide de 🤗 Datasets :

```python
>>> from datasets import load_dataset
>>> ds = load_dataset("username/my-dataset")
```

### Importer des données brutes dans les Storage Buckets

Sinon, si vous ne souhaitez pas publier un jeu de données mais simplement importer des fichiers de données brutes dans un [Storage Bucket](https://huggingface.co/docs/hub/storage-buckets) Hugging Face, vous pouvez utiliser :

```python
>>> from huggingface_hub import create_bucket, sync_bucket
>>> from tqdm.auto import tqdm
>>> from itertools import batched
>>> from tempfile import TemporaryDirectory
>>> import os
>>> create_bucket("username/my-bucket")
>>> bucket_files_location = "hf://buckets/username/my-bucket/path/to/raw/files"
>>> batch_size = 100
>>> for data_files in batched(tqdm(fs.glob(data_dir + pattern)), batch_size):
...     with TemporaryDirectory() as tmp_dir:
...         tmp_files = [os.path.join(tmp_dir, x[len(data_dir):]) for x in data_files]
...         fs.download(data_files, tmp_files)
...         sync_bucket(tmp_dir, bucket_files_location)
```

Consultez la documentation de [huggingface_hub](https://huggingface.co/docs/huggingface_hub) sur les Storage Buckets [ici](https://huggingface.co/docs/hub/storage-buckets) si vous recherchez d'autres options de téléchargement.

Ensuite, vous pouvez charger les fichiers bruts à l'aide de 🤗 Datasets, les transformer et téléverser les jeux de données finaux prêts pour l'IA, par exemple en mode streaming :

Si les fichiers sont dans un format pris en charge par 🤗 Datasets :

```python
>>> from datasets import load_dataset
>>> ds = load_dataset(bucket_files_location, streaming=True)
>>> ds = ds.map(...).filter(...)
>>> ds.push_to_hub("username/my-dataset", num_proc=4)
>>> # and later
>>> ds = load_dataset("username/my-dataset")
```

Sinon, vous pouvez utiliser votre propre fonction d’analyse de fichiers :

```python
>>> from datasets import IterableDataset
>>> from huggingface_hub import hffs
>>> data_files = hffs.find(bucket_files_location)
>>> num_shards = 1024  # For parallelism. PS: every shard should fit in RAM
>>> ds = IterableDataset.from_dict({"data_file": data_files}, num_shards=num_shards)
>>> def parse_data_files(data_files):
...     ...
...     return {"col_1": [...], "col_2": [...]}
>>> ds = ds.map(parse_data_files, batched=True, input_column=["data_file"])
>>> ds.push_to_hub("username/my-dataset", num_proc=4)
>>> # and later
>>> ds = load_dataset("username/my-dataset")
```