# Model Kartları oluşturun ve paylaşın

`huggingface_hub` kütüphanesi, Model Kartları oluşturma, paylaşma ve güncelleme için bir Python arayüzü sunar. Hub'daki Model Kartlarının ne olduğunu ve altyapıda nasıl çalıştığını daha derinlemesine incelemek için [özel dokümantasyon sayfasını](https://huggingface.co/docs/hub/models-cards) ziyaret edin.

## Hub'dan Bir Model Kartı Yükle

Hub'dan mevcut bir kartı yüklemek için [ModelCard.load()](/docs/huggingface_hub/main/tr/package_reference/cards#huggingface_hub.RepoCard.load) işlevini kullanabilirsiniz. Burada, kartı [`nateraw/vit-base-beans`](https://huggingface.co/nateraw/vit-base-beans) adresinden yüklüyoruz.

```python
from huggingface_hub import ModelCard

card = ModelCard.load('nateraw/vit-base-beans')
```

Bu kart, erişmek veya kullanmak isteyebileceğiniz bazı faydalı özniteliklere sahiptir:
  - `card.data`: Model kartının meta verilerini içeren bir [ModelCardData](/docs/huggingface_hub/main/tr/package_reference/cards#huggingface_hub.ModelCardData) örneği döndürür. Bu örneğin sözlük temsilini almak için `.to_dict()` çağrısını yapın.
  - `card.text`: Kartın metnini döndürür, *meta veri başlığı hariç*.
  - `card.content`: Kartın metin içeriğini, *meta veri başlığı dahil* olmak üzere döndürür.

## Model Kartları Oluşturma

### Metinden

Bir Model Card'ı metinden başlatmak için, kartın metin içeriğini başlatma sırasında `ModelCard`'a iletmeniz yeterlidir.

```python
content = """
---
language: en
license: mit
---

# My Model Card
"""

card = ModelCard(content)
card.data.to_dict() == {'language': 'en', 'license': 'mit'}  # True
```

Bunu yapmak isteyebileceğiniz bir başka yöntem f-strings kullanmaktır. Aşağıdaki örnekte, biz:

- Tanımladığımız metadata'yi YAML'e dönüştürmek ve model kartına YAML bloğunu eklemek için [ModelCardData.to_yaml()](/docs/huggingface_hub/main/tr/package_reference/cards#huggingface_hub.CardData.to_yaml) kullanın.
- Bir şablon değişkenini Python f-dizgileri (f-strings) aracılığıyla nasıl kullanabileceğinizi gösterin.

```python
card_data = ModelCardData(language='en', license='mit', library='timm')

example_template_var = 'nateraw'
content = f"""
---
{ card_data.to_yaml() }
---

# My Model Card

This model created by [@{example_template_var}](https://github.com/{example_template_var})
"""

card = ModelCard(content)
print(card)
```

Yukarıdaki örnek, bize aşağıdaki gibi görünen bir kart bırakacaktır:

```
---
language: en
license: mit
library: timm
---

# My Model Card

This model created by [@nateraw](https://github.com/nateraw)
```

### Bir Jinja Şablonundan

`Jinja2` yüklüyse, bir jinja şablon dosyasından Model Kartları oluşturabilirsiniz. Temel bir örneğe bakalım:

```python
from pathlib import Path

from huggingface_hub import ModelCard, ModelCardData

# Define your jinja template
template_text = """
---
{{ card_data }}
---

# Model Card for MyCoolModel

This model does this and that.

This model was created by [@{{ author }}](https://hf.co/{{author}}).
""".strip()

# Write the template to a file
Path('custom_template.md').write_text(template_text)

# Define card metadata
card_data = ModelCardData(language='en', license='mit', library_name='keras')

# Create card from template, passing it any jinja template variables you want.
# In our case, we'll pass author
card = ModelCard.from_template(card_data, template_path='custom_template.md', author='nateraw')
card.save('my_model_card_1.md')
print(card)
```

Oluşturulan kartın markdown görünümü şu şekildedir:

```
---
language: en
license: mit
library_name: keras
---

# Model Card for MyCoolModel

This model does this and that.

This model was created by [@nateraw](https://hf.co/nateraw).
```

Herhangi bir card.data öğesini güncellerseniz, bu değişiklik kartın kendisinde yansıtılır.

```
card.data.library_name = 'timm'
card.data.language = 'fr'
card.data.license = 'apache-2.0'
print(card)
```

Şimdi görebileceğiniz gibi, meta veri başlığı güncellenmiştir:

```
---
language: fr
license: apache-2.0
library_name: timm
---

# Model Card for MyCoolModel

This model does this and that.

This model was created by [@nateraw](https://hf.co/nateraw).
```

Kart verilerini güncelleyirken, [ModelCard.validate()](/docs/huggingface_hub/main/tr/package_reference/cards#huggingface_hub.RepoCard.validate) çağrısı yaparak kartın Hugging Face Hub üzerinde hâlâ geçerli olup olmadığını doğrulayabilirsiniz. Bu, kartın Hugging Face Hub üzerinde tanımlanmış tüm doğrulama kurallarını karşıladığından emin olmanızı sağlar.

### Varsayılan Şablon

Kendi şablonunuzu kullanmak yerine, doldurmak isteyebileceğiniz birçok bölüme sahip, tam donanımlı bir model kartı olan [varsayılan şablonu](https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/templates/modelcard_template.md) da kullanabilirsiniz. Arka planda, bir şablon dosyasını doldurmak için [Jinja2](https://jinja.palletsprojects.com/en/3.1.x/) kullanır.

> [!TIP]
> `from_template` kullanmak için Jinja2'nin yüklü olması gerekir. Bunu `pip install Jinja2` ile yapabilirsiniz.

```python
card_data = ModelCardData(language='en', license='mit', library_name='keras')
card = ModelCard.from_template(
    card_data,
    model_id='my-cool-model',
    model_description="this model does this and that",
    developers="Nate Raw",
    repo="https://github.com/huggingface/huggingface_hub",
)
card.save('my_model_card_2.md')
print(card)
```

## Model Kartlarını Paylaş

Hugging Face Hub ile kimlik doğrulamanız yapıldıysa (`hf auth login` veya [login()](/docs/huggingface_hub/main/tr/package_reference/authentication#huggingface_hub.login) kullanarak), kartları Hub'a göndermek için yalnızca [ModelCard.push_to_hub()](/docs/huggingface_hub/main/tr/package_reference/cards#huggingface_hub.RepoCard.push_to_hub) çağrısı yapmanız yeterlidir. Bunu nasıl yapacağımıza bir bakalım...

Öncelikle, kimliği doğrulanmış kullanıcının ad alanı altında 'hf-hub-modelcards-pr-test' adında yeni bir depo oluşturacağız:

```python
from huggingface_hub import whoami, create_repo

user = whoami()['name']
repo_id = f'{user}/hf-hub-modelcards-pr-test'
url = create_repo(repo_id, exist_ok=True)
```

Ardından, varsayılan şablonu kullanarak bir kart oluşturacağız (yukarıdaki bölümde tanımlananla aynı):

```python
card_data = ModelCardData(language='en', license='mit', library_name='keras')
card = ModelCard.from_template(
    card_data,
    model_id='my-cool-model',
    model_description="this model does this and that",
    developers="Nate Raw",
    repo="https://github.com/huggingface/huggingface_hub",
)
```

Son olarak, bunu hub'a yükleyeceğiz

```python
card.push_to_hub(repo_id)
```

Oluşturulan kartı [burada](https://huggingface.co/nateraw/hf-hub-modelcards-pr-test/blob/main/README.md) inceleyebilirsiniz.

Bunun yerine bir kartı bir çekme isteği olarak göndermek istiyorsanız, `push_to_hub` çağrılırken `create_pr=True` demeniz yeterlidir:

```python
card.push_to_hub(repo_id, create_pr=True)
```

Bu komutla oluşturulan sonuç PR'si [burada](https://huggingface.co/nateraw/hf-hub-modelcards-pr-test/discussions/3) görülebilir.

## Üst verileri güncelle

Bu bölümde, depo kartlarında hangi meta verilerin bulunduğunu ve bunların nasıl güncelleneceğini göreceğiz.

`metadata`, bir model, veri seti veya Space hakkında bazı yüksek düzeyde bilgiler sağlayan bir hash map (anahtar-değer) bağlamına atıfta bulunur. Bu bilgiler, modelin `pipeline type`, `model_id` veya `model_description` gibi ayrıntıları içerebilir. Daha fazla ayrıntı için şu kılavuzlara göz atabilirsiniz: [Model Card](https://huggingface.co/docs/hub/model-cards#model-card-metadata), [Dataset Card](https://huggingface.co/docs/hub/datasets-cards#dataset-card-metadata) ve [Spaces Settings](https://huggingface.co/docs/hub/spaces-settings#spaces-settings). Şimdi bu metadata'ları nasıl güncelleyeceğinize dair bazı örnekleri inceleyelim.

İlk bir örnekle başlayalım:

```python
>>> from huggingface_hub import metadata_update
>>> metadata_update("username/my-cool-model", {"pipeline_tag": "image-classification"})
```

Bu iki satır kodla, yeni bir `pipeline_tag` ayarlamak için meta verileri güncelleyeceksiniz.

Varsayılan olarak, kartta zaten mevcut olan bir anahtarı güncelleyemezsiniz. Bunu yapmak istiyorsanız, `overwrite=True` parametresini açıkça iletmeniz gerekir:

```python
>>> from huggingface_hub import metadata_update
>>> metadata_update("username/my-cool-model", {"pipeline_tag": "text-generation"}, overwrite=True)
```

Bazen, yazma izninizin olmadığı bir depoda bazı değişiklikler önermek isteyebilirsiniz. Bunu, o depoda bir PR oluşturarak yapabilirsiniz; bu, sahiplerin önerilerinizi inceleyip birleştirmesini sağlar.

```python
>>> from huggingface_hub import metadata_update
>>> metadata_update("someone/model", {"pipeline_tag": "text-classification"}, create_pr=True)
```

## Değerlendirme Sonuçlarını Dahil Et

`model-index` meta verilerine değerlendirme sonuçlarını dahil etmek için, ilgili değerlendirme sonuçlarınızla birlikte bir [EvalResult](/docs/huggingface_hub/main/tr/package_reference/cards#huggingface_hub.EvalResult) veya `EvalResult` listesi geçebilirsiniz. Arka planda, `card.data.to_dict()` çağrıldığında `model-index` oluşturulur. Bu işleyişin nasıl çalıştığına dair daha fazla bilgi için [Hub belgelerindeki bu bölümü](https://huggingface.co/docs/hub/models-cards#evaluation-results) inceleyebilirsiniz.

> [!TIP]
> Bu işlevi kullanmak için [ModelCardData](/docs/huggingface_hub/main/tr/package_reference/cards#huggingface_hub.ModelCardData) içinde `model_name` özniteliğini dahil etmeniz gerektiğini unutmayın.

```python
card_data = ModelCardData(
    language='en',
    license='mit',
    model_name='my-cool-model',
    eval_results = EvalResult(
        task_type='image-classification',
        dataset_type='beans',
        dataset_name='Beans',
        metric_type='accuracy',
        metric_value=0.7
    )
)

card = ModelCard.from_template(card_data)
print(card.data)
```

Oluşturulan `card.data` aşağıdaki gibi görünmelidir:

```
language: en
license: mit
model-index:
- name: my-cool-model
  results:
  - task:
      type: image-classification
    dataset:
      name: Beans
      type: beans
    metrics:
    - type: accuracy
      value: 0.7
```

Paylaşmak istediğiniz birden fazla değerlendirme sonucu varsa, bir `EvalResult` listesi geçmeniz yeterlidir:

```python
card_data = ModelCardData(
    language='en',
    license='mit',
    model_name='my-cool-model',
    eval_results = [
        EvalResult(
            task_type='image-classification',
            dataset_type='beans',
            dataset_name='Beans',
            metric_type='accuracy',
            metric_value=0.7
        ),
        EvalResult(
            task_type='image-classification',
            dataset_type='beans',
            dataset_name='Beans',
            metric_type='f1',
            metric_value=0.65
        )
    ]
)
card = ModelCard.from_template(card_data)
card.data
```

Bunun sonucunda aşağıdaki `card.data` ile kalmanız gerekir:

```
language: en
license: mit
model-index:
- name: my-cool-model
  results:
  - task:
      type: image-classification
    dataset:
      name: Beans
      type: beans
    metrics:
    - type: accuracy
      value: 0.7
    - type: f1
      value: 0.65
```