# Cartes de dépôt

La bibliothèque huggingface_hub fournit une interface Python pour créer, partager et mettre à jour les cartes de modèle/dataset. Consultez la [page de documentation dédiée](https://huggingface.co/docs/hub/models-cards) pour une vue plus approfondie de ce que sont les cartes de modèle sur le Hub et de leur fonctionnement interne. Vous pouvez également consulter notre [guide des cartes de modèle](../how-to-model-cards) pour vous faire une idée de la manière d’utiliser ces utilitaires dans vos propres projets.

## Carte du dépôt[[huggingface_hub.RepoCard]]

L'objet `RepoCard` est la classe parente de [ModelCard](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.ModelCard), [DatasetCard](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.DatasetCard) et `SpaceCard`.

#### huggingface_hub.RepoCard[[huggingface_hub.RepoCard]]

```python
huggingface_hub.RepoCard(content: str, ignore_metadata_errors: bool = False)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L37)

#### __init__[[huggingface_hub.RepoCard.__init__]]

```python
__init__(content: str, ignore_metadata_errors: bool = False)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L42)

**Paramètres :**

content (`str`) : Le contenu du fichier Markdown.

Initialise une RepoCard à partir d'un contenu en chaîne de caractères. Le contenu doit être un fichier Markdown avec un bloc YAML au début et un corps en Markdown.

Exemple :
```python
>>> from huggingface_hub.repocard import RepoCard
>>> text = '''
... ---
... language: en
... license: mit
... ---
...
... # My repo
... '''
>>> card = RepoCard(text)
>>> card.data.to_dict()
{'language': 'en', 'license': 'mit'}
>>> card.text
'\n# My repo\n'

```

> [!TIP]
> Lève l'erreur suivante :
>
> - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError) lorsque le contenu des métadonnées de la carte du dépôt n'est pas un dictionnaire.

#### from_template[[huggingface_hub.RepoCard.from_template]]

```python
from_template(card_data: CardData, template_path: str | None = None, template_str: str | None = None, **template_kwargs)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L289)

**Paramètres :**

card_data (`huggingface_hub.CardData`) : une instance de huggingface_hub.CardData contenant les métadonnées que vous souhaitez inclure dans l'en-tête YAML de la carte du dépôt sur le Hugging Face Hub.

template_path (`str`, *facultatif*) : Un chemin vers un fichier markdown avec des variables de modèle Jinja facultatives qui peuvent être remplies à l'aide de `template_kwargs`. Par défaut, le modèle par défaut est utilisé.

template_str (`str`, *facultatif*) : une chaîne de modèle Jinja brute avec des variables facultatives. Utilisé lorsque ni `template_path` ni le modèle par défaut ne sont appropriés. Ignoré si `template_path` est également fourni.

**Retourne :** [huggingface_hub.repocard.RepoCard](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.RepoCard)

Une instance de RepoCard avec les données de carte spécifiées et le contenu du modèle.

Initialiser un RepoCard à partir d'un modèle. Par défaut, il utilise le modèle par défaut.

Les modèles sont des modèles Jinja2 qui peuvent être personnalisés en passant des arguments nommés.

#### load[[huggingface_hub.RepoCard.load]]

```python
load(repo_id_or_path: str | pathlib.Path, repo_type: str | None = None, token: str | None = None, ignore_metadata_errors: bool = False)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L135)

**Paramètres :**

repo_id_or_path (`Union[str, Path]`) : L'identifiant du dépôt associé à un dépôt du Hugging Face Hub ou à un chemin de fichier local.

repo_type (`str`, *facultatif*) : Le type de dépôt Hugging Face vers lequel pousser. La valeur par défaut est None, ce qui utilise "model". Les autres options sont "dataset" et "space". Non utilisé lors du chargement depuis un chemin de fichier local. Si cela est appelé depuis une classe enfant, la valeur par défaut sera le `repo_type` de la classe enfant.

token (`str`, *facultatif*) : Jeton d'authentification, obtenu avec la méthode `huggingface_hub.HfApi.login`. Par défaut, le jeton stocké est utilisé.

ignore_metadata_errors (`str`) : Si True, les erreurs lors de l’analyse de la section de métadonnées seront ignorées. Certaines informations peuvent être perdues au cours du processus. À utiliser sous votre propre responsabilité.

**Retourne :** [huggingface_hub.repocard.RepoCard](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.RepoCard)

La RepoCard (ou sous-classe) initialisée à partir du fichier README.md du dépôt ou du chemin d'accès au fichier.

Initialiser un RepoCard à partir du README.md d’un dépôt du Hugging Face Hub ou d’un chemin de fichier local.

Exemple :
```python
>>> from huggingface_hub.repocard import RepoCard
>>> card = RepoCard.load("nateraw/food")
>>> assert card.data.tags == ["generated_from_trainer", "image-classification", "pytorch"]

```

#### push_to_hub[[huggingface_hub.RepoCard.push_to_hub]]

```python
push_to_hub(repo_id: str, token: str | None = None, repo_type: str | None = None, commit_message: str | None = None, commit_description: str | None = None, revision: str | None = None, create_pr: bool | None = None, parent_commit: str | None = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L226)

**Paramètres :**

repo_id (`str`) : L'identifiant du dépôt sur le Hugging Face Hub vers lequel pousser. Exemple : "nateraw/food".

token (`str`, *facultatif*) : Jeton d'authentification, obtenu avec la méthode `huggingface_hub.HfApi.login`. Par défaut, le jeton stocké est utilisé.

repo_type (`str`, *facultatif*, par défaut "model") : Le type de dépôt Hugging Face vers lequel pousser. Les options sont "model", "dataset" et "space". Si cette fonction est appelée par une classe enfant, elle prendra par défaut la valeur de `repo_type` de la classe enfant.

commit_message (`str`, *facultatif*) : Le résumé / titre / première ligne du commit généré.

commit_description (`str`, *facultatif*) : La description du commit généré.

revision (`str`, *facultatif*) : La révision git à partir de laquelle effectuer le commit. Par défaut, il s'agit de la tête de la branche `"main"`.

create_pr (`bool`, *facultatif*) : Indique s'il faut ou non créer une Pull Request avec cet engagement. La valeur par défaut est `False`.

parent_commit (`str`, *facultatif*) : L’OID / SHA de l’engagement parent, sous forme de chaîne hexadécimale. Les abréviations (7 premiers caractères) sont également prises en charge. Si spécifié et que `create_pr` est `False`, l’engagement échouera si `revision` ne pointe pas vers `parent_commit`. Si spécifié et que `create_pr` est `True`, la demande de tirage sera créée à partir de `parent_commit`. Spécifier `parent_commit` garantit que le dépôt n’a pas été modifié avant l’engagement des modifications, ce qui peut être particulièrement utile si le dépôt est mis à jour / engagé de manière concurrente.

**Retourne :** `str`

URL de l'engagement qui a mis à jour les métadonnées de la carte.

Pousser une RepoCard vers un dépôt du Hugging Face Hub.

#### save[[huggingface_hub.RepoCard.save]]

```python
save(filepath: pathlib.Path | str)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L115)

**Paramètres :**

filepath (`Union[Path, str]`) : Chemin du fichier Markdown à enregistrer.

Enregistrer une RepoCard dans un fichier.

Exemple :
```python
>>> from huggingface_hub.repocard import RepoCard
>>> card = RepoCard("---\nlanguage: en\n---\n# This is a test repo card")
>>> card.save("/tmp/test.md")

```

#### valider[[huggingface_hub.RepoCard.validate]]

```python
validate(repo_type: str | None = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L189)

**Paramètres :**

repo_type (`str`, *facultatif*, par défaut "model") : Le type de dépôt Hugging Face vers lequel pousser. Les options sont "model", "dataset" et "space". Si cette fonction est appelée depuis une classe enfant, la valeur par défaut sera le `repo_type` de la classe enfant.

Valide la carte selon la logique de validation des cartes du Hugging Face Hub. L'utilisation de cette fonction nécessite un accès à Internet, elle n'est donc appelée qu'internement par [huggingface_hub.repocard.RepoCard.push_to_hub()](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.RepoCard.push_to_hub).

> [!TIP]
> Lève les erreurs suivantes :
>
> - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError) si la carte échoue aux vérifications de validation. - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError) si la requête à l’API du Hub échoue pour toute autre raison.

## Données de carte[[huggingface_hub.CardData]]

L'objet [CardData](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.CardData) est la classe parente de [ModelCardData](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.ModelCardData) et [DatasetCardData](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.DatasetCardData).

#### huggingface_hub.CardData[[huggingface_hub.CardData]]

```python
huggingface_hub.CardData(ignore_metadata_errors: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard_data.py#L165)

Structure contenant les métadonnées d'une RepoCard.

[CardData](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.CardData) est la classe parente de [ModelCardData](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.ModelCardData) et de [DatasetCardData](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.DatasetCardData).

Les métadonnées peuvent être exportées sous forme de dictionnaire ou de YAML. L’export peut être personnalisé pour modifier la représentation des données (exemple : aplatir les résultats d’évaluation). `CardData` se comporte comme un dictionnaire (on peut récupérer, extraire et définir des valeurs) mais n’hérite pas de `dict` afin de permettre cette étape d’export.

#### get[[huggingface_hub.CardData.get]]

```python
get(key: str, default: typing.Any = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard_data.py#L228)

Obtenir la valeur pour une clé de métadonnées donnée.

#### pop[[huggingface_hub.CardData.pop]]

```python
pop(key: str, default: typing.Any = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard_data.py#L233)

Valeur Pop pour une clé de métadonnées donnée.

#### to_dict[[huggingface_hub.CardData.to_dict]]

```python
to_dict()
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard_data.py#L178)

**Retourne :** `dict`

CardData représenté sous forme de dictionnaire, prêt à être sérialisé dans un bloc YAML pour être inclus dans un fichier README.md.

Convertit CardData en dict.

#### to_yaml[[huggingface_hub.CardData.to_yaml]]

```python
to_yaml(line_break = None, original_order: list[str] | None = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard_data.py#L198)

**Paramètres :**

line_break (str, *facultatif*) : Le retour à la ligne à utiliser lors de la décharge en yaml.

original_order (`list[str]`, *facultatif*) : Si fourni, réordonne les champs de métadonnées pour qu’ils correspondent à cette liste avant l’écriture. Les clés absentes de `original_order` sont ajoutées après les clés listées, en conservant leur ordre relatif existant. Utile pour effectuer un aller-retour sur un bloc YAML sans réorganiser ses clés.

**Retourne :** `str`

CardData représenté sous forme de bloc YAML.

Déverse CardData dans un bloc YAML pour l'inclure dans un fichier README.md.

## Fiches de modèle

### ModelCard[[huggingface_hub.ModelCard]]

#### huggingface_hub.ModelCard[[huggingface_hub.ModelCard]]

```python
huggingface_hub.ModelCard(content: str, ignore_metadata_errors: bool = False)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L336)

#### from_template[[huggingface_hub.ModelCard.from_template]]

```python
from_template(card_data: ModelCardData, template_path: str | None = None, template_str: str | None = None, **template_kwargs)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L341)

**Paramètres :**

card_data (`huggingface_hub.ModelCardData`) : une instance de huggingface_hub.ModelCardData contenant les métadonnées que vous souhaitez inclure dans l'en-tête YAML de la carte du modèle sur le Hugging Face Hub.

template_path (`str`, *facultatif*) : Un chemin vers un fichier markdown avec des variables de modèle Jinja facultatives qui peuvent être remplies à l'aide de `template_kwargs`. Par défaut, le modèle par défaut est utilisé.

template_str (`str`, *facultatif*) : une chaîne de modèle Jinja brute avec des variables facultatives. Utilisé lorsque ni `template_path` ni le modèle par défaut ne sont appropriés. Ignoré si `template_path` est également fourni.

**Retourne :** [huggingface_hub.ModelCard](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.ModelCard)

Une instance de ModelCard avec les données de carte spécifiées et le contenu du modèle.

Initialise une ModelCard à partir d'un modèle. Par défaut, il utilise le modèle par défaut, que l'on peut trouver ici : https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/templates/modelcard_template.md

Les modèles sont des modèles Jinja2 qui peuvent être personnalisés en passant des arguments nommés.

Exemple :
```python
>>> from huggingface_hub import ModelCard, ModelCardData, EvalResult

>>> # Using the Default Template
>>> card_data = ModelCardData(
...     language='en',
...     license='mit',
...     library_name='timm',
...     tags=['image-classification', 'resnet'],
...     datasets=['beans'],
...     metrics=['accuracy'],
... )
>>> card = ModelCard.from_template(
...     card_data,
...     model_description='This model does x + y...'
... )

>>> # Including Evaluation Results
>>> card_data = ModelCardData(
...     language='en',
...     tags=['image-classification', 'resnet'],
...     eval_results=[
...         EvalResult(
...             task_type='image-classification',
...             dataset_type='beans',
...             dataset_name='Beans',
...             metric_type='accuracy',
...             metric_value=0.9,
...         ),
...     ],
...     model_name='my-cool-model',
... )
>>> card = ModelCard.from_template(card_data)

>>> # Using a Custom Template
>>> card_data = ModelCardData(
...     language='en',
...     tags=['image-classification', 'resnet']
... )
>>> card = ModelCard.from_template(
...     card_data=card_data,
...     template_path='./src/huggingface_hub/templates/modelcard_template.md',
...     custom_template_var='custom value',  # will be replaced in template if it exists
... )

```

### ModelCardData[[huggingface_hub.ModelCardData]]

#### huggingface_hub.ModelCardData[[huggingface_hub.ModelCardData]]

```python
huggingface_hub.ModelCardData(base_model: str | list[str] | None = None, datasets: str | list[str] | None = None, eval_results: list[huggingface_hub.repocard_data.EvalResult] | None = None, language: str | list[str] | None = None, library_name: str | None = None, license: str | None = None, license_name: str | None = None, license_link: str | None = None, metrics: list[str] | None = None, model_name: str | None = None, pipeline_tag: str | None = None, tags: list[str] | None = None, ignore_metadata_errors: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard_data.py#L271)

**Paramètres :**

base_model (`str` ou `list[str]`, *facultatif*) : L'identifiant du modèle de base dont le modèle est dérivé. Cela s'applique par exemple si votre modèle est un fine-tune ou un adaptateur d'un modèle existant. La valeur doit être l'ID d'un modèle sur le Hub (ou une liste d'IDs si votre modèle est dérivé de plusieurs modèles). La valeur par défaut est None.

datasets (`Union[str, list[str]]`, *facultatif*) : Jeu de données ou liste de jeux de données utilisés pour entraîner ce modèle. Doit être un identifiant de jeu de données trouvé sur https://hf.co/datasets. Valeur par défaut : None.

eval_results (`Union[list[EvalResult], EvalResult]`, *facultatif*) : Liste de `huggingface_hub.EvalResult` qui définissent les résultats d'évaluation du modèle. Si fournis, `model_name` est utilisé comme nom sur les classements de PapersWithCode. La valeur par défaut est `None`.

language (`Union[str, list[str]]`, *facultatif*) : Langue des données d'entraînement ou des métadonnées du modèle. Il doit s'agir d'un code ISO 639-1, 639-2 ou 639-3 (deux/trois lettres), ou d'une valeur spéciale comme "code", "multilingual". La valeur par défaut est `None`.

library_name (`str`, *facultatif*) : Nom de la bibliothèque utilisée par ce modèle. Exemple : keras ou toute bibliothèque de https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/src/model-libraries.ts. Valeur par défaut : None.

license (`str`, *facultatif*) : Licence de ce modèle. Exemple : apache-2.0 ou toute licence de https://huggingface.co/docs/hub/repositories-licenses. Valeur par défaut : None.

license_name (`str`, *facultatif*) : Nom de la licence de ce modèle. La valeur par défaut est None. À utiliser en conjonction avec `license_link`. Les licences courantes (Apache-2.0, MIT, CC-BY-SA-4.0) n'ont pas besoin de nom. Dans ce cas, utilisez `license` à la place.

license_link (`str`, *facultatif*) : Lien vers la licence de ce modèle. La valeur par défaut est None. À utiliser en conjonction avec `license_name`. Les licences courantes (Apache-2.0, MIT, CC-BY-SA-4.0) n'ont pas besoin de lien. Dans ce cas, utilisez `license` à la place.

metrics (`list[str]`, *facultatif*) : Liste de métriques utilisées pour évaluer ce modèle. Doit être un nom de métrique pouvant être trouvé sur https://hf.co/metrics. Exemple : 'accuracy'. Valeur par défaut : None.

model_name (`str`, *facultatif*) : Un nom pour ce modèle. Il est utilisé avec `eval_results` pour construire le `model-index` dans les métadonnées de la carte. Le nom fourni ici est celui qui sera utilisé sur les classements de PapersWithCode. Si None est fourni, le nom du dépôt est utilisé par défaut. Valeur par défaut : None.

pipeline_tag (`str`, *facultatif*) : Le tag de pipeline associé au modèle. Exemple : "text-classification".

tags (`list[str]`, *facultatif*) : Liste de tags à ajouter à votre modèle, utilisables lors du filtrage sur le Hugging Face Hub. Valeur par défaut : None.

ignore_metadata_errors (`str`) : Si True, les erreurs lors de l’analyse de la section de métadonnées seront ignorées. Certaines informations peuvent être perdues au cours du processus. À utiliser sous votre propre responsabilité.

kwargs (`dict`, *facultatif*) : Métadonnées supplémentaires qui seront ajoutées à la carte du modèle. Valeur par défaut : None.

Métadonnées de la carte du modèle utilisées par Hugging Face Hub lorsqu’elles sont incluses en haut de votre README.md

Exemple :
```python
>>> from huggingface_hub import ModelCardData
>>> card_data = ModelCardData(
...     language="en",
...     license="mit",
...     library_name="timm",
...     tags=['image-classification', 'resnet'],
... )
>>> card_data.to_dict()
{'language': 'en', 'license': 'mit', 'library_name': 'timm', 'tags': ['image-classification', 'resnet']}

```

## Cartes de jeu de données

Les fiches de jeu de données sont également connues sous le nom de Data Cards dans la communauté de l'IA.

### DatasetCard[[huggingface_hub.DatasetCard]]

#### huggingface_hub.DatasetCard[[huggingface_hub.DatasetCard]]

```python
huggingface_hub.DatasetCard(content: str, ignore_metadata_errors: bool = False)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L420)

#### from_template[[huggingface_hub.DatasetCard.from_template]]

```python
from_template(card_data: DatasetCardData, template_path: str | None = None, template_str: str | None = None, **template_kwargs)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L425)

**Paramètres :**

card_data (`huggingface_hub.DatasetCardData`) : une instance de huggingface_hub.DatasetCardData contenant les métadonnées que vous souhaitez inclure dans l'en-tête YAML de la carte du jeu de données sur le Hugging Face Hub.

template_path (`str`, *facultatif*) : Un chemin vers un fichier markdown avec des variables de modèle Jinja facultatives qui peuvent être remplies à l'aide de `template_kwargs`. Par défaut, le modèle par défaut est utilisé.

template_str (`str`, *facultatif*) : une chaîne de modèle Jinja brute avec des variables facultatives. Utilisé lorsque ni `template_path` ni le modèle par défaut ne sont appropriés. Ignoré si `template_path` est également fourni.

**Retourne :** [huggingface_hub.DatasetCard](/docs/huggingface_hub/v2.4.0/fr/package_reference/cards#huggingface_hub.DatasetCard)

Une instance de DatasetCard avec les données de carte spécifiées et le contenu du modèle.

Initialise une DatasetCard à partir d'un modèle. Par défaut, il utilise le modèle par défaut, que l'on peut trouver ici : https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/templates/datasetcard_template.md

Les modèles sont des modèles Jinja2 qui peuvent être personnalisés en passant des arguments nommés.

Exemple :
```python
>>> from huggingface_hub import DatasetCard, DatasetCardData

>>> # Using the Default Template
>>> card_data = DatasetCardData(
...     language='en',
...     license='mit',
...     annotations_creators='crowdsourced',
...     task_categories=['text-classification'],
...     task_ids=['sentiment-classification', 'text-scoring'],
...     multilinguality='monolingual',
...     pretty_name='My Text Classification Dataset',
... )
>>> card = DatasetCard.from_template(
...     card_data,
...     pretty_name=card_data.pretty_name,
... )

>>> # Using a Custom Template
>>> card_data = DatasetCardData(
...     language='en',
...     license='mit',
... )
>>> card = DatasetCard.from_template(
...     card_data=card_data,
...     template_path='./src/huggingface_hub/templates/datasetcard_template.md',
...     custom_template_var='custom value',  # will be replaced in template if it exists
... )

```

### DatasetCardData[[huggingface_hub.DatasetCardData]]

#### huggingface_hub.DatasetCardData[[huggingface_hub.DatasetCardData]]

```python
huggingface_hub.DatasetCardData(language: str | list[str] | None = None, license: str | list[str] | None = None, annotations_creators: str | list[str] | None = None, language_creators: str | list[str] | None = None, multilinguality: str | list[str] | None = None, size_categories: str | list[str] | None = None, source_datasets: list[str] | None = None, task_categories: str | list[str] | None = None, task_ids: str | list[str] | None = None, paperswithcode_id: str | None = None, pretty_name: str | None = None, train_eval_index: dict | None = None, config_names: str | list[str] | None = None, ignore_metadata_errors: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard_data.py#L400)

**Paramètres :**

language (`list[str]`, *facultatif*) : Langue des données ou des métadonnées du jeu de données. Il doit s'agir d'un code ISO 639-1, 639-2 ou 639-3 (deux/trois lettres), ou d'une valeur spéciale comme "code", "multilingual".

license (`Union[str, list[str]]`, *facultatif*) : Licence(s) de ce jeu de données. Exemple : apache-2.0 ou toute licence de https://huggingface.co/docs/hub/repositories-licenses.

annotations_creators (`Union[str, list[str]]`, *facultatif*) : La manière dont les annotations du jeu de données ont été créées. Les options sont : 'found', 'crowdsourced', 'expert-generated', 'machine-generated', 'no-annotation', 'other'.

language_creators (`Union[str, list[str]]`, *facultatif*) : La manière dont les données textuelles du jeu de données ont été créées. Les options sont : 'found', 'crowdsourced', 'expert-generated', 'machine-generated', 'other'

multilinguality (`Union[str, list[str]]`, *facultatif*) : Indique si le jeu de données est multilingue. Les options sont : 'monolingual', 'multilingual', 'translation', 'other'.

size_categories (`Union[str, list[str]]`, *facultatif*) : Le nombre d'exemples dans le jeu de données. Les options sont : 'n<1K', '1K1T' et 'other'.

source_datasets (`list[str]]`, *facultatif*) : Indique si le jeu de données est un jeu de données original ou s'il a été étendu à partir d'un autre jeu de données existant. Les options sont : 'original' et 'extended'.

task_categories (`Union[str, list[str]]`, *facultatif*) : Quelles catégories de tâches le jeu de données prend-il en charge ?

task_ids (`Union[str, list[str]]`, *facultatif*) : Quelles tâches spécifiques le jeu de données prend-il en charge ?

paperswithcode_id (`str`, *facultatif*) : ID du jeu de données sur PapersWithCode.

pretty_name (`str`, *facultatif*) : Un nom plus lisible pour le jeu de données. (ex. "Cats vs. Dogs")

train_eval_index (`dict`, *facultatif*) : Un dictionnaire qui décrit la spécification nécessaire pour effectuer une évaluation sur le Hub. S'il n'est pas fourni, il sera récupéré à partir de la clé 'train-eval-index' des kwargs.

config_names (`Union[str, list[str]]`, *facultatif*) : Une liste des configurations de jeu de données disponibles pour le jeu de données.

Métadonnées de la carte de jeu de données utilisées par Hugging Face Hub lorsqu’elles sont incluses en haut de votre README.md

## Space Cards

### SpaceCard[[huggingface_hub.SpaceCard]]

#### huggingface_hub.SpaceCard[[huggingface_hub.SpaceCard]]

```python
huggingface_hub.SpaceCard(content: str, ignore_metadata_errors: bool = False)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L488)

### SpaceCardData[[huggingface_hub.SpaceCardData]]

#### huggingface_hub.SpaceCardData[[huggingface_hub.SpaceCardData]]

```python
huggingface_hub.SpaceCardData(title: str | None = None, sdk: str | None = None, sdk_version: str | None = None, python_version: str | None = None, app_file: str | None = None, app_port: int | None = None, license: str | None = None, duplicated_from: str | None = None, models: list[str] | None = None, datasets: list[str] | None = None, tags: list[str] | None = None, ignore_metadata_errors: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard_data.py#L480)

**Paramètres :**

title (`str`, *facultatif*) : Titre de l'Espace.

sdk (`str`, *facultatif*) : SDK de l'Espace (l'un des `gradio`, `streamlit`, `docker` ou `static`).

sdk_version (`str`, *facultatif*) : Version du SDK utilisé (si SDK Gradio/Streamlit).

python_version (`str`, *facultatif*) : version de Python utilisée dans le Space (si SDK Gradio/Streamlit).

app_file (`str`, *facultatif*) : Chemin vers votre fichier d'application principal (contenant du code Python gradio ou streamlit, ou du code html statique). Le chemin est relatif à la racine du dépôt.

app_port (`str`, *facultatif*) : Port sur lequel votre application est en cours d'exécution. Utilisé uniquement si sdk est `docker`.

license (`str`, *facultatif*) : Licence de ce modèle. Exemple : apache-2.0 ou toute licence de https://huggingface.co/docs/hub/repositories-licenses.

duplicated_from (`str`, *facultatif*) : ID de l'espace d'origine s'il s'agit d'un espace dupliqué.

models (`list[str]`, *facultatif*) : Liste des modèles liés à cet Espace. Doit être un identifiant de modèle trouvé sur https://hf.co/models.

datasets (`list[str]`, *facultatif*) : Liste des jeux de données liés à cet Espace. Doit être un identifiant de jeu de données trouvé sur https://hf.co/datasets.

tags (`list[str]`, *facultatif*) : Liste de tags à ajouter à votre Space, utilisables lors du filtrage sur le Hub.

ignore_metadata_errors (`str`) : Si True, les erreurs lors de l’analyse de la section de métadonnées seront ignorées. Certaines informations peuvent être perdues au cours du processus. À utiliser sous votre propre responsabilité.

kwargs (`dict`, *facultatif*) : métadonnées supplémentaires qui seront ajoutées à la carte de l'espace.

Métadonnées de la carte Space utilisées par Hugging Face Hub lorsqu’elles sont incluses en haut de votre README.md

Pour obtenir une référence exhaustive de la configuration des Spaces, veuillez consulter https://huggingface.co/docs/hub/spaces-config-reference#spaces-configuration-reference.

Exemple :
```python
>>> from huggingface_hub import SpaceCardData
>>> card_data = SpaceCardData(
...     title="Dreambooth Training",
...     license="mit",
...     sdk="gradio",
...     duplicated_from="multimodalart/dreambooth-training"
... )
>>> card_data.to_dict()
{'title': 'Dreambooth Training', 'sdk': 'gradio', 'license': 'mit', 'duplicated_from': 'multimodalart/dreambooth-training'}
```

## Utilitaires

### EvalResult[[huggingface_hub.EvalResult]]

#### huggingface_hub.EvalResult[[huggingface_hub.EvalResult]]

```python
huggingface_hub.EvalResult(task_type: str, dataset_type: str, dataset_name: str, metric_type: str, metric_value: typing.Any, task_name: str | None = None, dataset_config: str | None = None, dataset_split: str | None = None, dataset_revision: str | None = None, dataset_args: dict[str, typing.Any] | None = None, metric_name: str | None = None, metric_config: str | None = None, metric_args: dict[str, typing.Any] | None = None, verified: bool | None = None, verify_token: str | None = None, source_name: str | None = None, source_url: str | None = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard_data.py#L13)

**Paramètres :**

task_type (`str`) : L'identifiant de la tâche. Exemple : "image-classification".

dataset_type (`str`) : L'identifiant du jeu de données. Exemple : "common_voice". Utilisez l'identifiant du jeu de données depuis https://hf.co/datasets.

dataset_name (`str`) : Un nom lisible pour le jeu de données. Exemple : "Common Voice (French)".

metric_type (`str`) : L'identifiant de la métrique. Exemple : "wer". Utilisez l'identifiant de métrique depuis https://hf.co/metrics.

metric_value (`Any`) : La valeur de la métrique. Exemple : 0.9 ou "20.0 ± 1.2".

task_name (`str`, *facultatif*) : Un nom lisible pour la tâche. Exemple : "Speech Recognition".

dataset_config (`str`, *facultatif*) : Le nom de la configuration du jeu de données utilisé dans `load_dataset()`. Exemple : fr dans `load_dataset("common_voice", "fr")`. Consultez la documentation de `datasets` pour plus d'informations : https://hf.co/docs/datasets/package_reference/loading_methods#datasets.load_dataset.name

dataset_split (`str`, *facultatif*) : La partition utilisée dans `load_dataset()`. Exemple : "test".

dataset_revision (`str`, *facultatif*) : La révision (aussi appelée Git Sha) du jeu de données utilisé dans `load_dataset()`. Exemple : 5503434ddd753f426f4b38109466949a1217c2bb

dataset_args (`dict[str, Any]`, *facultatif*) : Les arguments passés lors de `Metric.compute()`. Exemple pour `bleu` : `{"max_order": 4}`

metric_name (`str`, *facultatif*) : Un nom lisible pour la métrique. Exemple : "Test WER".

metric_config (`str`, *facultatif*) : Le nom de la configuration de la métrique utilisée dans `load_metric()`. Exemple : bleurt-large-512 dans `load_metric("bleurt", "bleurt-large-512")`. Consultez la documentation de `datasets` pour plus d'informations : https://huggingface.co/docs/datasets/v2.1.0/en/loading#load-configurations

metric_args (`dict[str, Any]`, *facultatif*) : Les arguments passés lors de `Metric.compute()`. Exemple pour `bleu` : max_order: 4

verified (`bool`, *facultatif*) : Indique si les métriques proviennent du [service d'évaluation](https://huggingface.co/spaces/autoevaluate/model-evaluator) de Hugging Face ou non. Calculé automatiquement par Hugging Face, ne pas définir.

verify_token (`str`, *facultatif*) : Un JSON Web Token utilisé pour vérifier si les métriques proviennent du [service d'évaluation](https://huggingface.co/spaces/autoevaluate/model-evaluator) de Hugging Face ou non.

source_name (`str`, *facultatif*) : Le nom de la source du résultat d'évaluation. Exemple : "Open LLM Leaderboard".

source_url (`str`, *facultatif*) : L'URL de la source du résultat d'évaluation. Exemple : "https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard".

Représentation aplatie des résultats d'évaluation individuels trouvés dans le model-index des Model Cards.

Pour plus d'informations sur la spécification model-index, voir https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1.

#### is_equal_except_value[[huggingface_hub.EvalResult.is_equal_except_value]]

```python
is_equal_except_value(other: EvalResult)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard_data.py#L145)

Retourne True si `self` et `other` décrivent exactement la même métrique mais avec une valeur différente.

### model_index_to_eval_results[[huggingface_hub.repocard_data.model_index_to_eval_results]]

#### huggingface_hub.repocard_data.model_index_to_eval_results[[huggingface_hub.repocard_data.model_index_to_eval_results]]

```python
huggingface_hub.repocard_data.model_index_to_eval_results(model_index: list)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard_data.py#L561)

**Paramètres :**

model_index (`list[dict[str, Any]]`) : Structure de données d'index de modèle, provenant probablement d'un fichier README.md sur le Hugging Face Hub.

**Retourne :** model_name (`str`)

Le nom du modèle tel qu'il figure dans l'index des modèles. Il est utilisé comme identifiant du modèle sur les classements tels que PapersWithCode. eval_results (`list[EvalResult]`) : une liste d'objets `huggingface_hub.EvalResult` contenant les métriques signalées dans le model_index fourni.

Prend un index de modèle en entrée et renvoie le nom du modèle ainsi qu'une liste d'objets `huggingface_hub.EvalResult`.

Une spécification détaillée de l’index du modèle peut être trouvée ici : https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1

Exemple :
```python
>>> from huggingface_hub.repocard_data import model_index_to_eval_results
>>> # Define a minimal model index
>>> model_index = [
...     {
...         "name": "my-cool-model",
...         "results": [
...             {
...                 "task": {
...                     "type": "image-classification"
...                 },
...                 "dataset": {
...                     "type": "beans",
...                     "name": "Beans"
...                 },
...                 "metrics": [
...                     {
...                         "type": "accuracy",
...                         "value": 0.9
...                     }
...                 ]
...             }
...         ]
...     }
... ]
>>> model_name, eval_results = model_index_to_eval_results(model_index)
>>> model_name
'my-cool-model'
>>> eval_results[0].task_type
'image-classification'
>>> eval_results[0].metric_type
'accuracy'

```

### eval_results_to_model_index[[huggingface_hub.repocard_data.eval_results_to_model_index]]

#### huggingface_hub.repocard_data.eval_results_to_model_index[[huggingface_hub.repocard_data.eval_results_to_model_index]]

```python
huggingface_hub.repocard_data.eval_results_to_model_index(model_name: str, eval_results: list)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard_data.py#L681)

**Paramètres :**

model_name (`str`) : Nom du modèle (ex. "my-cool-model"). Il est utilisé comme identifiant du modèle sur les classements tels que PapersWithCode.

eval_results (`list[EvalResult]`) : Liste d'objets `huggingface_hub.EvalResult` contenant les métriques à signaler dans le model-index.

**Retourne :** model_index (`list[dict[str, Any]]`)

Les eval_results convertis en model-index.

Prend en entrée un nom de modèle donné et une liste de `huggingface_hub.EvalResult` et renvoie un model-index valide compatible avec le format attendu par le Hugging Face Hub.

Exemple :
```python
>>> from huggingface_hub.repocard_data import eval_results_to_model_index, EvalResult
>>> # Define minimal eval_results
>>> eval_results = [
...     EvalResult(
...         task_type="image-classification",  # Required
...         dataset_type="beans",  # Required
...         dataset_name="Beans",  # Required
...         metric_type="accuracy",  # Required
...         metric_value=0.9,  # Required
...     )
... ]
>>> eval_results_to_model_index("my-cool-model", eval_results)
[{'name': 'my-cool-model', 'results': [{'task': {'type': 'image-classification'}, 'dataset': {'name': 'Beans', 'type': 'beans'}, 'metrics': [{'type': 'accuracy', 'value': 0.9}]}]}]

```

### metadata_eval_result[[huggingface_hub.metadata_eval_result]]

#### huggingface_hub.metadata_eval_result[[huggingface_hub.metadata_eval_result]]

```python
huggingface_hub.metadata_eval_result(model_pretty_name: str, task_pretty_name: str, task_id: str, metrics_pretty_name: str, metrics_id: str, metrics_value: typing.Any, dataset_pretty_name: str, dataset_id: str, metrics_config: str | None = None, metrics_verified: bool = False, dataset_config: str | None = None, dataset_split: str | None = None, dataset_revision: str | None = None, metrics_verification_token: str | None = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L560)

**Paramètres :**

model_pretty_name (`str`) : Le nom du modèle en langage naturel.

task_pretty_name (`str`) : Le nom d'une tâche en langage naturel.

task_id (`str`) : Exemple : automatic-speech-recognition. Un identifiant de tâche.

metrics_pretty_name (`str`) : Un nom pour la métrique en langage naturel. Exemple : Test WER.

metrics_id (`str`) : Exemple : wer. Un identifiant de métrique issu de https://hf.co/metrics.

metrics_value (`Any`) : La valeur de la métrique. Exemple : 20.0 ou "20.0 ± 1.2".

dataset_pretty_name (`str`) : Le nom du jeu de données en langage naturel.

dataset_id (`str`) : Exemple : common_voice. Un identifiant de jeu de données depuis https://hf.co/datasets.

metrics_config (`str`, *facultatif*) : Le nom de la configuration de la métrique utilisée dans `load_metric()`. Exemple : bleurt-large-512 dans `load_metric("bleurt", "bleurt-large-512")`.

metrics_verified (`bool`, *facultatif*, valeur par défaut `False`) : Indique si les métriques proviennent du [service d'évaluation](https://huggingface.co/spaces/autoevaluate/model-evaluator) de Hugging Face ou non. Calculé automatiquement par Hugging Face, ne pas définir.

dataset_config (`str`, *facultatif*) : Exemple : fr. Le nom de la configuration du jeu de données utilisé dans `load_dataset()`.

dataset_split (`str`, *facultatif*) : Exemple : test. Le nom de la partition de jeu de données utilisée dans `load_dataset()`.

dataset_revision (`str`, *facultatif*) : Exemple : 5503434ddd753f426f4b38109466949a1217c2bb. Le nom de la révision du jeu de données utilisé dans `load_dataset()`.

metrics_verification_token (`bool`, *facultatif*) : Un JSON Web Token utilisé pour vérifier si les métriques proviennent du [service d'évaluation](https://huggingface.co/spaces/autoevaluate/model-evaluator) de Hugging Face ou non.

**Retourne :** `dict`

un dictionnaire de métadonnées contenant le résultat d'un modèle évalué sur un jeu de données.

Crée un dictionnaire de métadonnées avec le résultat d'un modèle évalué sur un jeu de données.

Exemple :
```python
>>> from huggingface_hub import metadata_eval_result
>>> results = metadata_eval_result(
...         model_pretty_name="RoBERTa fine-tuned on ReactionGIF",
...         task_pretty_name="Text Classification",
...         task_id="text-classification",
...         metrics_pretty_name="Accuracy",
...         metrics_id="accuracy",
...         metrics_value=0.2662102282047272,
...         dataset_pretty_name="ReactionJPEG",
...         dataset_id="julien-c/reactionjpeg",
...         dataset_config="default",
...         dataset_split="test",
... )
>>> results == {
...     'model-index': [
...         {
...             'name': 'RoBERTa fine-tuned on ReactionGIF',
...             'results': [
...                 {
...                     'task': {
...                         'type': 'text-classification',
...                         'name': 'Text Classification'
...                     },
...                     'dataset': {
...                         'name': 'ReactionJPEG',
...                         'type': 'julien-c/reactionjpeg',
...                         'config': 'default',
...                         'split': 'test'
...                     },
...                     'metrics': [
...                         {
...                             'type': 'accuracy',
...                             'value': 0.2662102282047272,
...                             'name': 'Accuracy',
...                             'verified': False
...                         }
...                     ]
...                 }
...             ]
...         }
...     ]
... }
True

```

### metadata_update[[huggingface_hub.metadata_update]]

#### huggingface_hub.metadata_update[[huggingface_hub.metadata_update]]

```python
huggingface_hub.metadata_update(repo_id: str, metadata: dict, repo_type: str | None = None, overwrite: bool = False, token: str | None = None, commit_message: str | None = None, commit_description: str | None = None, revision: str | None = None, create_pr: bool = False, parent_commit: str | None = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/repocard.py#L688)

**Paramètres :**

repo_id (`str`) : Le nom du dépôt.

metadata (`dict`) : Un dictionnaire contenant les métadonnées à mettre à jour.

repo_type (`str`, *facultatif*) : Définir sur `"dataset"` ou `"space"` lors d'une mise à jour vers un jeu de données ou un espace, sur `None` ou `"model"` lors d'une mise à jour vers un modèle. La valeur par défaut est `None`.

overwrite (`bool`, *facultatif*, valeur par défaut `False`) : Si défini sur `True`, un champ existant peut être écrasé ; sinon, toute tentative d'écrasement d'un champ existant provoquera une erreur.

token (`str`, *facultatif*) : Le jeton d'authentification Hugging Face.

commit_message (`str`, *facultatif*) : Le résumé / titre / première ligne du commit généré. La valeur par défaut est `f"Update metadata with huggingface_hub"`

commit_description (`str`, *facultatif*) : La description du commit généré

revision (`str`, *facultatif*) : La révision git à partir de laquelle effectuer le commit. Par défaut, il s'agit de la tête de la branche `"main"`.

create_pr (`boolean`, *facultatif*) : Indique s'il faut ou non créer une Pull Request à partir de `revision` avec cet engagement. La valeur par défaut est `False`.

parent_commit (`str`, *facultatif*) : L’OID / SHA de l’engagement parent, sous forme de chaîne hexadécimale. Les abréviations (7 premiers caractères) sont également prises en charge. Si spécifié et que `create_pr` est `False`, l’engagement échouera si `revision` ne pointe pas vers `parent_commit`. Si spécifié et que `create_pr` est `True`, la demande de tirage sera créée à partir de `parent_commit`. Spécifier `parent_commit` garantit que le dépôt n’a pas été modifié avant l’engagement des modifications, ce qui peut être particulièrement utile si le dépôt est mis à jour / engagé de manière concurrente.

**Retourne :** `str`

URL de l'engagement qui a mis à jour les métadonnées de la carte.

Updates the metadata in the README.md of a repository on the Hugging Face Hub. If the README.md file doesn't exist yet, a new one is created with metadata and the default ModelCard or DatasetCard template. For `space` repo, an error is thrown as a Space cannot exist without a `README.md` file.

Exemple :
```python
>>> from huggingface_hub import metadata_update
>>> metadata = {'model-index': [{'name': 'RoBERTa fine-tuned on ReactionGIF',
...             'results': [{'dataset': {'name': 'ReactionGIF',
...                                      'type': 'julien-c/reactiongif'},
...                           'metrics': [{'name': 'Recall',
...                                        'type': 'recall',
...                                        'value': 0.7762102282047272}],
...                          'task': {'name': 'Text Classification',
...                                   'type': 'text-classification'}}]}]}
>>> url = metadata_update("hf-internal-testing/reactiongif-roberta-card", metadata)

```