# Cards de Repositório

A biblioteca huggingface_hub fornece uma interface em Python para criar, compartilhar e atualizar Model/Dataset Cards. Visite a [página de documentação dedicada](https://huggingface.co/docs/hub/models-cards) para uma visão mais aprofundada do que são os Model Cards no Hub e como funcionam por baixo dos panos. Você também pode conferir nosso [guia de Model Cards](../how-to-model-cards) para ter uma ideia de como usar essas utilidades em seus próprios projetos.

## Cartão do repositório[[huggingface_hub.RepoCard]]

O objeto `RepoCard` é a classe pai de [ModelCard](/docs/huggingface_hub/v2.4.0/pt/package_reference/cards#huggingface_hub.ModelCard), [DatasetCard](/docs/huggingface_hub/v2.4.0/pt/package_reference/cards#huggingface_hub.DatasetCard) e `SpaceCard`.

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

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

[Fonte](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)
```

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

**Parâmetros:**

content (`str`) : O conteúdo do arquivo Markdown.

Inicialize um RepoCard a partir do conteúdo de uma string. O conteúdo deve ser um arquivo Markdown com um bloco YAML no início e um corpo em Markdown.

Exemplo:
```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]
> Gera o seguinte erro:
>
> - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError) quando o conteúdo dos metadados do cartão do repositório não é um dicionário.

#### 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)
```

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

**Parâmetros:**

card_data (`huggingface_hub.CardData`) : uma instância de huggingface_hub.CardData contendo os metadados que você deseja incluir no cabeçalho YAML do cartão do repositório no Hugging Face Hub.

template_path (`str`, *opcional*) : Um caminho para um arquivo markdown com variáveis de template Jinja opcionais que podem ser preenchidas com `template_kwargs`. O padrão é o template padrão.

template_str (`str`, *opcional*) : Uma string de modelo Jinja bruta com variáveis opcionais. Usada quando nem o `template_path` nem o modelo padrão são apropriados. Ignorado se o `template_path` também for fornecido.

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

Uma instância de RepoCard com os dados da card especificados e o conteúdo do template.

Inicialize um RepoCard a partir de um modelo. Por padrão, ele usa o modelo padrão.

Templates são templates Jinja2 que podem ser personalizados passando argumentos de palavra-chave.

#### 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)
```

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

**Parâmetros:**

repo_id_or_path (`Union[str, Path]`) : O ID do repositório associado a um repositório do Hugging Face Hub ou a um caminho de arquivo local.

repo_type (`str`, *opcional*) : O tipo de repositório do Hugging Face para o qual será feito o push. O padrão é None, o que usará "model". As outras opções são "dataset" e "space". Não é usado ao carregar de um caminho de arquivo local. Se isso for chamado de uma classe filha, o valor padrão será o `repo_type` da classe filha.

token (`str`, *opcional*) : Token de autenticação, obtido com o método `huggingface_hub.HfApi.login`. O padrão será o token armazenado.

ignore_metadata_errors (`str`) : Se True, os erros durante a análise da seção de metadados serão ignorados. Algumas informações podem ser perdidas durante o processo. Use por sua conta e risco.

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

O RepoCard (ou subclasse) inicializado a partir do arquivo README.md do repositório ou do caminho do arquivo.

Inicialize um RepoCard a partir do README.md de um repositório do Hugging Face Hub ou de um caminho de arquivo local.

Exemplo:
```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)
```

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

**Parâmetros:**

repo_id (`str`) : O ID do repositório no Hugging Face Hub para o qual será feito o push. Exemplo: "nateraw/food".

token (`str`, *opcional*) : Token de autenticação, obtido com o método `huggingface_hub.HfApi.login`. O padrão será o token armazenado.

repo_type (`str`, *opcional*, padrão "model") : O tipo de repositório do Hugging Face para o qual será feito o push. As opções são "model", "dataset" e "space". Se esta função for chamada por uma classe filha, o padrão será o `repo_type` da classe filha.

commit_message (`str`, *opcional*) : O resumo / título / primeira linha do commit gerado.

commit_description (`str`, *opcional*) : A descrição do commit gerado.

revision (`str`, *opcional*) : A revisão do git a partir da qual o commit será feito. O padrão é o topo da branch `"main"`.

create_pr (`bool`, *opcional*) : Se deve ou não criar um Pull Request com este commit. O padrão é `False`.

parent_commit (`str`, *opcional*) : O OID / SHA do commit pai, como uma string hexadecimal. Abreviações (os 7 primeiros caracteres) também são suportadas. Se especificado e `create_pr` for `False`, o commit falhará se `revision` não apontar para `parent_commit`. Se especificado e `create_pr` for `True`, a pull request será criada a partir de `parent_commit`. Especificar `parent_commit` garante que o repositório não tenha sido alterado antes de commitar as mudanças, o que pode ser especialmente útil se o repositório for atualizado / commitado de forma concorrente.

**Retorna:** `str`

URL do commit que atualizou os metadados do card.

Envie um RepoCard para um repositório no Hugging Face Hub.

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

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

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

**Parâmetros:**

filepath (`Union[Path, str]`) : Caminho do arquivo markdown para salvar.

Salve um RepoCard em um arquivo.

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

```

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

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

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

**Parâmetros:**

repo_type (`str`, *opcional*, padrão "model") : O tipo de repositório do Hugging Face para o qual será feito o push. As opções são "model", "dataset" e "space". Se esta função for chamada de uma classe filha, o padrão será o `repo_type` da classe filha.

Valida o card contra a lógica de validação de cards do Hugging Face Hub. O uso desta função requer acesso à internet, portanto, ela é chamada apenas internamente por [huggingface_hub.repocard.RepoCard.push_to_hub()](/docs/huggingface_hub/v2.4.0/pt/package_reference/cards#huggingface_hub.RepoCard.push_to_hub).

> [!TIP]
> Gera os seguintes erros:
>
> - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError) se o cartão falhar nas verificações de validação. - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError) se a solicitação à API do Hub falhar por qualquer outro motivo.

## Dados do cartão[[huggingface_hub.CardData]]

O objeto [CardData](/docs/huggingface_hub/v2.4.0/pt/package_reference/cards#huggingface_hub.CardData) é a classe pai de [ModelCardData](/docs/huggingface_hub/v2.4.0/pt/package_reference/cards#huggingface_hub.ModelCardData) e [DatasetCardData](/docs/huggingface_hub/v2.4.0/pt/package_reference/cards#huggingface_hub.DatasetCardData).

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

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

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

Estrutura contendo metadados de um RepoCard.

[CardData](/docs/huggingface_hub/v2.4.0/pt/package_reference/cards#huggingface_hub.CardData) é a classe pai de [ModelCardData](/docs/huggingface_hub/v2.4.0/pt/package_reference/cards#huggingface_hub.ModelCardData) e [DatasetCardData](/docs/huggingface_hub/v2.4.0/pt/package_reference/cards#huggingface_hub.DatasetCardData).

Metadados podem ser exportados como um dicionário ou YAML. A exportação pode ser personalizada para alterar a representação dos dados (exemplo: achatar os resultados de avaliação). `CardData` se comporta como um dicionário (pode obter, remover e definir valores), mas não herda de `dict` para permitir essa etapa de exportação.

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

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

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

Obtém o valor para uma chave de metadados específica.

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

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

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

Valor pop para uma chave de metadados específica.

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

```python
to_dict()
```

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

**Retorna:** `dict`

CardData representado como um dicionário pronto para ser exportado em um bloco YAML para inclusão em um arquivo README.md.

Converte CardData em um dict.

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

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

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

**Parâmetros:**

line_break (str, *opcional*) : A quebra de linha a ser usada ao despejar em yaml.

original_order (`list[str]`, *opcional*) : Se fornecida, reordena os campos de metadados para corresponder a esta lista antes de despejar. Quaisquer chaves não presentes em `original_order` são adicionadas após as chaves listadas, preservando sua ordem relativa existente. Útil para fazer round-trip de um bloco YAML sem embaralhar suas chaves.

**Retorna:** `str`

CardData representado como um bloco YAML.

Exporta CardData para um bloco YAML para inclusão em um arquivo README.md.

## Cartões de Modelo

### ModelCard[[huggingface_hub.ModelCard]]

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

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

[Fonte](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)
```

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

**Parâmetros:**

card_data (`huggingface_hub.ModelCardData`) : uma instância de huggingface_hub.ModelCardData contendo os metadados que você deseja incluir no cabeçalho YAML do cartão do modelo no Hugging Face Hub.

template_path (`str`, *opcional*) : Um caminho para um arquivo markdown com variáveis de template Jinja opcionais que podem ser preenchidas com `template_kwargs`. O padrão é o template padrão.

template_str (`str`, *opcional*) : Uma string de modelo Jinja bruta com variáveis opcionais. Usada quando nem o `template_path` nem o modelo padrão são apropriados. Ignorado se o `template_path` também for fornecido.

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

Uma instância de ModelCard com os dados da card especificados e o conteúdo do template.

Inicialize um ModelCard a partir de um modelo. Por padrão, ele usa o modelo padrão, que pode ser encontrado aqui: https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/templates/modelcard_template.md

Templates são templates Jinja2 que podem ser personalizados passando argumentos de palavra-chave.

Exemplo:
```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)
```

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

**Parâmetros:**

base_model (`str` ou `list[str]`, *opcional*) : O identificador do modelo base do qual o modelo deriva. Isso se aplica, por exemplo, se o seu modelo for um ajuste fino ou um adaptador de um modelo existente. O valor deve ser o ID de um modelo no Hub (ou uma lista de IDs, se o seu modelo deriva de múltiplos modelos). O padrão é None.

datasets (`Union[str, list[str]]`, *opcional*) : Conjunto de dados ou lista de conjuntos de dados usados para treinar este modelo. Deve ser um ID de conjunto de dados encontrado em https://hf.co/datasets. O valor padrão é None.

eval_results (`Union[list[EvalResult], EvalResult]`, *opcional*) : Lista de `huggingface_hub.EvalResult` que definem os resultados de avaliação do modelo. Se fornecido, `model_name` é usado como nome nos rankings do PapersWithCode. O valor padrão é `None`.

language (`Union[str, list[str]]`, *opcional*) : Idioma dos dados de treinamento ou metadados do modelo. Deve ser um código ISO 639-1, 639-2 ou 639-3 (dois/três letras) ou um valor especial como "code", "multilingual". O padrão é `None`.

library_name (`str`, *opcional*) : Nome da biblioteca usada por este modelo. Exemplo: keras ou qualquer biblioteca de https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/src/model-libraries.ts. Padrão: None.

license (`str`, *opcional*) : Licença deste modelo. Exemplo: apache-2.0 ou qualquer licença de https://huggingface.co/docs/hub/repositories-licenses. Padrão: None.

license_name (`str`, *opcional*) : Nome da licença deste modelo. O padrão é None. Deve ser usado em conjunto com `license_link`. Licenças comuns (Apache-2.0, MIT, CC-BY-SA-4.0) não precisam de um nome. Nesse caso, use `license` em vez disso.

license_link (`str`, *opcional*) : Link para a licença deste modelo. O padrão é None. Deve ser usado em conjunto com `license_name`. Licenças comuns (Apache-2.0, MIT, CC-BY-SA-4.0) não precisam de um link. Nesse caso, use `license` em vez disso.

metrics (`list[str]`, *opcional*) : Lista de métricas usadas para avaliar este modelo. Deve ser um nome de métrica que pode ser encontrado em https://hf.co/metrics. Exemplo: 'accuracy'. Padrão: None.

model_name (`str`, *opcional*) : Um nome para este modelo. Ele é usado junto com `eval_results` para construir o `model-index` nos metadados do card. O nome fornecido aqui é o que será usado nos rankings do PapersWithCode. Se None for fornecido, o nome do repositório é usado como padrão. Padrão: None.

pipeline_tag (`str`, *opcional*) : A tag de pipeline associada ao modelo. Exemplo: "text-classification".

tags (`list[str]`, *opcional*) : Lista de tags para adicionar ao seu modelo, que podem ser usadas ao filtrar no Hugging Face Hub. O valor padrão é None.

ignore_metadata_errors (`str`) : Se True, os erros durante a análise da seção de metadados serão ignorados. Algumas informações podem ser perdidas durante o processo. Use por sua conta e risco.

kwargs (`dict`, *opcional*) : Metadados adicionais que serão adicionados ao cartão do modelo. O padrão é None.

Metadados do Model Card usados pelo Hugging Face Hub quando incluídos no topo do seu README.md

Exemplo:
```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']}

```

## Cartões de Dataset

Dataset cards também são conhecidos como Data Cards na comunidade de ML.

### DatasetCard[[huggingface_hub.DatasetCard]]

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

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

[Fonte](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)
```

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

**Parâmetros:**

card_data (`huggingface_hub.DatasetCardData`) : uma instância de huggingface_hub.DatasetCardData contendo os metadados que você deseja incluir no cabeçalho YAML do cartão do conjunto de dados no Hugging Face Hub.

template_path (`str`, *opcional*) : Um caminho para um arquivo markdown com variáveis de template Jinja opcionais que podem ser preenchidas com `template_kwargs`. O padrão é o template padrão.

template_str (`str`, *opcional*) : Uma string de modelo Jinja bruta com variáveis opcionais. Usada quando nem o `template_path` nem o modelo padrão são apropriados. Ignorado se o `template_path` também for fornecido.

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

Uma instância de DatasetCard com os dados e o conteúdo da card especificados a partir do modelo.

Inicialize um DatasetCard a partir de um modelo. Por padrão, ele usa o modelo padrão, que pode ser encontrado aqui: https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/templates/datasetcard_template.md

Templates são templates Jinja2 que podem ser personalizados passando argumentos de palavra-chave.

Exemplo:
```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)
```

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

**Parâmetros:**

language (`list[str]`, *opcional*) : Idioma dos dados ou metadados do conjunto de dados. Deve ser um código ISO 639-1, 639-2 ou 639-3 (dois/três letras) ou um valor especial como "code", "multilingual".

license (`Union[str, list[str]]`, *opcional*) : Licença(s) deste conjunto de dados. Exemplo: apache-2.0 ou qualquer licença de https://huggingface.co/docs/hub/repositories-licenses.

annotations_creators (`Union[str, list[str]]`, *opcional*) : Como as anotações do conjunto de dados foram criadas. As opções são: 'found', 'crowdsourced', 'expert-generated', 'machine-generated', 'no-annotation', 'other'.

language_creators (`Union[str, list[str]]`, *opcional*) : Como os dados baseados em texto no conjunto de dados foram criados. As opções são: 'found', 'crowdsourced', 'expert-generated', 'machine-generated', 'other'

multilinguality (`Union[str, list[str]]`, *opcional*) : Se o conjunto de dados é multilíngue. As opções são: 'monolingual', 'multilingual', 'translation', 'other'.

size_categories (`Union[str, list[str]]`, *opcional*) : O número de exemplos no conjunto de dados. As opções são: 'n<1K', '1K1T' e 'other'.

source_datasets (`list[str]]`, *opcional*) : Indica se o conjunto de dados é um conjunto de dados original ou estendido a partir de outro conjunto de dados existente. As opções são: 'original' e 'extended'.

task_categories (`Union[str, list[str]]`, *opcional*) : Que categorias de tarefa o conjunto de dados suporta?

task_ids (`Union[str, list[str]]`, *opcional*) : Quais tarefas específicas o conjunto de dados suporta?

paperswithcode_id (`str`, *opcional*) : ID do conjunto de dados no PapersWithCode.

pretty_name (`str`, *opcional*) : Um nome mais legível para o conjunto de dados. (ex. "Cats vs. Dogs")

train_eval_index (`dict`, *opcional*) : Um dicionário que descreve a especificação necessária para realizar a avaliação no Hub. Se não for fornecido, ele será obtido da chave 'train-eval-index' dos kwargs.

config_names (`Union[str, list[str]]`, *opcional*) : Uma lista dos configs de dataset disponíveis para o dataset.

Metadados do Dataset Card que são usados pelo Hugging Face Hub quando incluídos no topo do seu README.md

## Cartões de Espaço

### SpaceCard[[huggingface_hub.SpaceCard]]

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

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

[Fonte](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)
```

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

**Parâmetros:**

title (`str`, *opcional*) : Título do Space.

sdk (`str`, *opcional*) : SDK do Space (um de `gradio`, `streamlit`, `docker` ou `static`).

sdk_version (`str`, *opcional*) : Versão do SDK utilizado (se for o SDK do Gradio/Streamlit).

python_version (`str`, *opcional*) : versão do Python usada no Space (se for Gradio/Streamlit sdk).

app_file (`str`, *opcional*) : Caminho para o seu arquivo de aplicativo principal (que contém código Python gradio ou streamlit, ou código html estático). O caminho é relativo à raiz do repositório.

app_port (`str`, *opcional*) : Porta em que seu aplicativo está em execução. Usado apenas se o sdk for `docker`.

license (`str`, *opcional*) : Licença deste modelo. Exemplo: apache-2.0 ou qualquer licença de https://huggingface.co/docs/hub/repositories-licenses.

duplicated_from (`str`, *opcional*) : ID do Space original, caso este seja um Space duplicado.

models (`list[str]`, *opcional*) : Lista de modelos relacionados a este Space. Deve ser um ID de dataset encontrado em https://hf.co/models.

datasets (`list[str]`, *opcional*) : Lista de conjuntos de dados relacionados a este Space. Deve ser um ID de conjunto de dados encontrado em https://hf.co/datasets.

tags (`list[str]`, *opcional*) : Lista de tags para adicionar ao seu Space, que podem ser usadas ao filtrar no Hub.

ignore_metadata_errors (`str`) : Se True, os erros durante a análise da seção de metadados serão ignorados. Algumas informações podem ser perdidas durante o processo. Use por sua conta e risco.

kwargs (`dict`, *opcional*) : Metadados adicionais que serão adicionados ao cartão do espaço.

Metadados do Space Card usados pelo Hugging Face Hub quando incluídos no topo do seu README.md

Para obter uma referência exaustiva da configuração de Spaces, visite https://huggingface.co/docs/hub/spaces-config-reference#spaces-configuration-reference.

Exemplo:
```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'}
```

## Utilitários

### 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)
```

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

**Parâmetros:**

task_type (`str`) : O identificador da tarefa. Exemplo: "image-classification".

dataset_type (`str`) : O identificador do conjunto de dados. Exemplo: "common_voice". Use o id do conjunto de dados de https://hf.co/datasets.

dataset_name (`str`) : Um nome legível para o conjunto de dados. Exemplo: "Common Voice (French)".

metric_type (`str`) : O identificador da métrica. Exemplo: "wer". Use o id da métrica de https://hf.co/metrics.

metric_value (`Any`) : O valor da métrica. Exemplo: 0.9 ou "20.0 ± 1.2".

task_name (`str`, *opcional*) : Um nome legível para a tarefa. Exemplo: "Speech Recognition".

dataset_config (`str`, *opcional*) : O nome da configuração do conjunto de dados usado em `load_dataset()`. Exemplo: fr em `load_dataset("common_voice", "fr")`. Consulte a documentação de `datasets` para mais informações: https://hf.co/docs/datasets/package_reference/loading_methods#datasets.load_dataset.name

dataset_split (`str`, *opcional*) : A divisão usada em `load_dataset()`. Exemplo: "test".

dataset_revision (`str`, *opcional*) : A revisão (também conhecida como Git Sha) do conjunto de dados usado em `load_dataset()`. Exemplo: 5503434ddd753f426f4b38109466949a1217c2bb

dataset_args (`dict[str, Any]`, *opcional*) : Os argumentos passados durante `Metric.compute()`. Exemplo para `bleu`: `{"max_order": 4}`

metric_name (`str`, *opcional*) : Um nome legível para a métrica. Exemplo: "Test WER".

metric_config (`str`, *opcional*) : O nome da configuração de métrica usada em `load_metric()`. Exemplo: bleurt-large-512 em `load_metric("bleurt", "bleurt-large-512")`. Veja a documentação do `datasets` para mais informações: https://huggingface.co/docs/datasets/v2.1.0/en/loading#load-configurations

metric_args (`dict[str, Any]`, *opcional*) : Os argumentos passados durante `Metric.compute()`. Exemplo para `bleu`: max_order: 4

verified (`bool`, *opcional*) : Indica se as métricas provêm do [serviço de avaliação](https://huggingface.co/spaces/autoevaluate/model-evaluator) do Hugging Face ou não. Calculado automaticamente pelo Hugging Face, não defina.

verify_token (`str`, *opcional*) : Um JSON Web Token usado para verificar se as métricas têm origem no [serviço de avaliação](https://huggingface.co/spaces/autoevaluate/model-evaluator) do Hugging Face ou não.

source_name (`str`, *opcional*) : O nome da origem do resultado da avaliação. Exemplo: "Open LLM Leaderboard".

source_url (`str`, *opcional*) : A URL da origem do resultado da avaliação. Exemplo: "https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard".

Representação achatada dos resultados individuais de avaliação encontrados no model-index dos Model Cards.

Para mais informações sobre a especificação do model-index, consulte 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)
```

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

Retorna True se `self` e `other` descrevem exatamente a mesma métrica, mas com um valor diferente.

### 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)
```

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

**Parâmetros:**

model_index (`list[dict[str, Any]]`) : Uma estrutura de dados de índice de modelo, provavelmente originada de um arquivo README.md no Hugging Face Hub.

**Retorna:** model_name (`str`)

O nome do modelo conforme encontrado no índice do modelo. Isso é usado como identificador do modelo em rankings como PapersWithCode. eval_results (`list[EvalResult]`): Uma lista de objetos `huggingface_hub.EvalResult` contendo as métricas relatadas no model_index fornecido.

Recebe um índice de modelo e retorna o nome do modelo e uma lista de objetos `huggingface_hub.EvalResult`.

Uma especificação detalhada do índice do modelo pode ser encontrada aqui: https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1

Exemplo:
```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)
```

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

**Parâmetros:**

model_name (`str`) : Nome do modelo (ex. "my-cool-model"). Isso é usado como identificador do modelo em rankings como o PapersWithCode.

eval_results (`list[EvalResult]`) : Lista de objetos `huggingface_hub.EvalResult` contendo as métricas a serem reportadas no model-index.

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

Os eval_results convertidos em um model-index.

Recebe o nome do modelo e uma lista de `huggingface_hub.EvalResult` e retorna um model-index válido que será compatível com o formato esperado pelo Hugging Face Hub.

Exemplo:
```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)
```

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

**Parâmetros:**

model_pretty_name (`str`) : O nome do modelo em linguagem natural.

task_pretty_name (`str`) : O nome de uma tarefa em linguagem natural.

task_id (`str`) : Exemplo: automatic-speech-recognition. Um id de tarefa.

metrics_pretty_name (`str`) : Um nome para a métrica em linguagem natural. Exemplo: Test WER.

metrics_id (`str`) : Exemplo: wer. Um id de métrica de https://hf.co/metrics.

metrics_value (`Any`) : O valor da métrica. Exemplo: 20.0 ou "20.0 ± 1.2".

dataset_pretty_name (`str`) : O nome do conjunto de dados em linguagem natural.

dataset_id (`str`) : Exemplo: common_voice. Um id de dataset de https://hf.co/datasets.

metrics_config (`str`, *opcional*) : O nome da configuração de métrica usada em `load_metric()`. Exemplo: bleurt-large-512 em `load_metric("bleurt", "bleurt-large-512")`.

metrics_verified (`bool`, *opcional*, padrão `False`) : Indica se as métricas se originam do [serviço de avaliação](https://huggingface.co/spaces/autoevaluate/model-evaluator) do Hugging Face ou não. Calculado automaticamente pelo Hugging Face, não defina.

dataset_config (`str`, *opcional*) : Exemplo: fr. O nome da configuração do conjunto de dados usado em `load_dataset()`.

dataset_split (`str`, *opcional*) : Exemplo: test. O nome da divisão do conjunto de dados usado em `load_dataset()`.

dataset_revision (`str`, *opcional*) : Exemplo: 5503434ddd753f426f4b38109466949a1217c2bb. O nome da revisão do conjunto de dados usado em `load_dataset()`.

metrics_verification_token (`bool`, *opcional*) : Um JSON Web Token usado para verificar se as métricas têm origem no [serviço de avaliação](https://huggingface.co/spaces/autoevaluate/model-evaluator) do Hugging Face ou não.

**Retorna:** `dict`

um dicionário de metadados com o resultado de um modelo avaliado em um conjunto de dados.

Cria um dicionário de metadados com o resultado de um modelo avaliado em um conjunto de dados.

Exemplo:
```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)
```

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

**Parâmetros:**

repo_id (`str`) : O nome do repositório.

metadata (`dict`) : Um dicionário contendo os metadados a serem atualizados.

repo_type (`str`, *opcional*) : Defina como `"dataset"` ou `"space"` se estiver atualizando para um dataset ou space, `None` ou `"model"` se estiver atualizando para um model. O padrão é `None`.

overwrite (`bool`, *opcional*, padrão `False`) : Se definido como `True`, um campo existente pode ser sobrescrito; caso contrário, tentar sobrescrever um campo existente causará um erro.

token (`str`, *opcional*) : O token de autenticação do Hugging Face.

commit_message (`str`, *opcional*) : O resumo / título / primeira linha do commit gerado. O padrão é `f"Update metadata with huggingface_hub"`

commit_description (`str`, *opcional*) : A descrição do commit gerado

revision (`str`, *opcional*) : A revisão do git a partir da qual o commit será feito. O padrão é o topo da branch `"main"`.

create_pr (`boolean`, *opcional*) : Se deve ou não criar um Pull Request a partir de `revision` com esse commit. O padrão é `False`.

parent_commit (`str`, *opcional*) : O OID / SHA do commit pai, como uma string hexadecimal. Abreviações (os 7 primeiros caracteres) também são suportadas. Se especificado e `create_pr` for `False`, o commit falhará se `revision` não apontar para `parent_commit`. Se especificado e `create_pr` for `True`, a pull request será criada a partir de `parent_commit`. Especificar `parent_commit` garante que o repositório não tenha sido alterado antes de commitar as mudanças, o que pode ser especialmente útil se o repositório for atualizado / commitado de forma concorrente.

**Retorna:** `str`

URL do commit que atualizou os metadados do card.

Atualiza os metadados no README.md de um repositório no Hugging Face Hub. Se o arquivo README.md ainda não existir, um novo será criado com os metadados e o template padrão de ModelCard ou DatasetCard. Para um repositório `space`, um erro é lançado, pois um Space não pode existir sem um arquivo `README.md`.

Exemplo:
```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)

```