Pytorch
TensorFlow

#
Membagikan Model yang Telah Dilatih

Dalam langkah-langkah berikut, kita akan melihat cara termudah untuk membagikan model yang telah dilatih ke 🤗 Hub. Tersedia berbagai alat dan utilitas yang mempermudah proses berbagi dan memperbarui model langsung di Hub, yang akan kita eksplorasi di bawah ini.

Kami mendorong semua pengguna yang melatih model untuk berkontribusi dengan membagikan model mereka kepada komunitas — membagikan model, bahkan jika dilatih pada dataset yang sangat spesifik, dapat membantu orang lain dengan menghemat waktu dan sumber daya komputasi serta memberikan akses ke artefak terlatih yang berguna. Sebagai gantinya, Anda juga bisa mendapatkan manfaat dari pekerjaan yang telah dilakukan oleh orang lain!

Ada tiga cara untuk membuat repositori model baru:

- Menggunakan API `push_to_hub`
- Menggunakan pustaka Python `huggingface_hub`
- Menggunakan antarmuka web

Setelah Anda membuat repositori, Anda dapat mengunggah berkas ke dalamnya melalui `git` dan `git-lfs`. Kita akan membahas proses pembuatan repositori model dan pengunggahan file ke dalamnya pada bagian-bagian berikut.

##
Menggunakan API push_to_hub

Cara termudah untuk mengunggah file ke Hub adalah dengan memanfaatkan API `push_to_hub`.

Sebelum melanjutkan, Anda perlu membuat token autentikasi agar API `huggingface_hub` mengetahui siapa Anda dan namespace mana yang Anda miliki akses tulisnya. Pastikan Anda berada di lingkungan yang telah terinstal `transformers` (lihat Setup). Jika Anda berada di notebook, Anda bisa menggunakan fungsi berikut untuk login:

    from huggingface_hub import notebook_login

    notebook_login()

Di terminal, Anda bisa menjalankan:

    huggingface-cli login

Pada kedua kasus, Anda akan diminta memasukkan nama pengguna dan kata sandi Anda, yang sama dengan yang Anda gunakan untuk masuk ke Hub. Jika Anda belum memiliki akun di Hub, Anda bisa membuatnya di sini.

Bagus! Sekarang Anda memiliki token autentikasi yang tersimpan di folder cache Anda. Mari buat beberapa repositori!

Jika Anda telah bereksperimen dengan API `Trainer` untuk melatih model, cara termudah untuk mengunggahnya ke Hub adalah dengan menyetel `push_to_hub=True` saat mendefinisikan `TrainingArguments` Anda:

    from transformers import TrainingArguments

    training_args = TrainingArguments(
        "bert-finetuned-mrpc", save_strategy="epoch", push_to_hub=True
    )

Saat Anda memanggil `trainer.train()`, `Trainer` akan mengunggah model Anda ke Hub setiap kali disimpan (di sini setiap epoch) ke repositori dalam namespace Anda. Repositori tersebut akan dinamai sesuai direktori output yang Anda pilih (di sini `bert-finetuned-mrpc`), tetapi Anda dapat memilih nama lain dengan `hub_model_id = "nama_lain"`.

Untuk mengunggah model ke organisasi tempat Anda menjadi anggota, cukup gunakan `hub_model_id = "organisasi_saya/nama_repo"`.

Setelah pelatihan selesai, Anda sebaiknya menjalankan `trainer.push_to_hub()` terakhir untuk mengunggah versi terakhir model Anda. Ini juga akan menghasilkan model card secara otomatis dengan metadata yang relevan, melaporkan hyperparameter dan hasil evaluasi! Berikut adalah contoh isi dari model card tersebut:

Pada level yang lebih rendah, Anda dapat mengakses Model Hub langsung melalui objek model, tokenizer, dan konfigurasi menggunakan metode `push_to_hub()`. Metode ini menangani pembuatan repositori sekaligus mengunggah file model dan tokenizer langsung ke repositori — tanpa perlu konfigurasi manual.

Untuk memahaminya, mari kita inisialisasi model dan tokenizer terlebih dahulu:

    from transformers import AutoModelForMaskedLM, AutoTokenizer

    checkpoint = "camembert-base"

    model = AutoModelForMaskedLM.from_pretrained(checkpoint)
    tokenizer = AutoTokenizer.from_pretrained(checkpoint)

Anda bebas melakukan apa saja terhadap ini — menambahkan token pada tokenizer, melatih model, menyempurnakannya. Setelah puas dengan hasil akhir model, bobot, dan tokenizer-nya, Anda dapat langsung menggunakan metode `push_to_hub()` pada objek `model`:

    model.push_to_hub("dummy-model")

Ini akan membuat repositori baru bernama `dummy-model` di profil Anda dan mengisinya dengan file model Anda. Lakukan hal yang sama untuk tokenizer agar semua file tersedia dalam repositori tersebut:

    tokenizer.push_to_hub("dummy-model")

Jika Anda termasuk dalam suatu organisasi, cukup tentukan argumen `organization` untuk mengunggah ke namespace organisasi tersebut:

    tokenizer.push_to_hub("dummy-model", organization="huggingface")

Jika Anda ingin menggunakan token khusus dari Hugging Face, Anda juga dapat menentukannya pada metode `push_to_hub()`:

    tokenizer.push_to_hub("dummy-model", organization="huggingface", use_auth_token="<TOKEN>")

Sekarang buka Model Hub untuk menemukan model yang baru saja Anda unggah: https://huggingface.co/user-or-organization/dummy-model

Klik tab “Files and versions”, dan Anda seharusnya melihat file seperti pada tangkapan layar berikut:

✏️ Coba sendiri! Ambil model dan tokenizer dari checkpoint `bert-base-cased` dan unggah ke repositori dalam namespace Anda menggunakan metode `push_to_hub()`. Periksa apakah repositori muncul dengan benar di halaman Anda sebelum menghapusnya.

Seperti yang telah Anda lihat, metode `push_to_hub()` menerima berbagai argumen, yang memungkinkan pengunggahan ke repositori tertentu, namespace organisasi, atau menggunakan token API berbeda. Kami sarankan untuk memeriksa spesifikasi metode ini langsung dari dokumentasi 🤗 Transformers untuk mengetahui apa saja yang bisa dilakukan.

Metode `push_to_hub()` dibangun di atas pustaka Python `huggingface_hub`, yang menyediakan API langsung ke Hugging Face Hub. Ini telah terintegrasi dalam 🤗 Transformers dan berbagai pustaka pembelajaran mesin lainnya seperti `allenlp`. Meskipun fokus kita dalam bab ini adalah integrasi dengan 🤗 Transformers, mengintegrasikannya ke dalam kode atau pustaka Anda sendiri juga sangat mudah.

Lanjutkan ke bagian terakhir untuk melihat cara mengunggah file ke repositori yang telah Anda buat!

##
Menggunakan Pustaka Python huggingface_hub

Pustaka Python `huggingface_hub` adalah paket yang menyediakan serangkaian alat untuk mengelola model dan dataset di Hub. Ia menawarkan metode dan kelas sederhana untuk tugas umum seperti mendapatkan informasi tentang repositori dan mengelolanya. API yang disediakan bekerja di atas git untuk mempermudah manajemen konten dan integrasi Hub dalam proyek dan pustaka Anda.

Seperti halnya saat menggunakan API `push_to_hub`, Anda harus memiliki token API yang tersimpan di cache. Untuk melakukan ini, gunakan perintah `login` dari CLI seperti dijelaskan pada bagian sebelumnya (jangan lupa tambahkan karakter `!` jika menjalankan dari Google Colab):

    huggingface-cli login

Paket `huggingface_hub` menawarkan beberapa metode dan kelas yang berguna untuk tujuan kita. Pertama-tama, ada beberapa metode untuk mengelola pembuatan dan penghapusan repositori, serta hal lainnya:

    from huggingface_hub import (
        # Manajemen pengguna
        login,
        logout,
        whoami,

        # Pembuatan dan manajemen repositori
        create_repo,
        delete_repo,
        update_repo_visibility,

        # Beberapa metode untuk mengambil/mengubah informasi tentang isi repositori
        list_models,
        list_datasets,
        list_metrics,
        list_repo_files,
        upload_file,
        delete_file,
    )

Selain itu, paket ini juga menyediakan kelas `Repository` yang sangat kuat untuk mengelola repositori lokal. Kita akan menjelajahi metode-metode ini dan kelas tersebut di bagian-bagian berikut untuk memahami cara memanfaatkannya.

Metode `create_repo` dapat digunakan untuk membuat repositori baru di Hub:

    from huggingface_hub import create_repo

    create_repo("dummy-model")

Ini akan membuat repositori `dummy-model` dalam namespace Anda. Jika Anda ingin, Anda dapat menentukan organisasi tempat repositori ini berada dengan argumen `organization`:

    from huggingface_hub import create_repo

    create_repo("dummy-model", organization="huggingface")

Ini akan membuat repositori `dummy-model` dalam namespace `huggingface`, dengan asumsi Anda merupakan anggota organisasi tersebut. Argumen lain yang mungkin berguna adalah:

- `private`, untuk menentukan apakah repositori tersebut dapat diakses publik atau tidak.
- `token`, jika Anda ingin menggunakan token tertentu dan bukan token yang tersimpan di cache.
- `repo_type`, jika Anda ingin membuat `dataset` atau `space` alih-alih model. Nilai yang diterima: `"dataset"` dan `"space"`.

Setelah repositori dibuat, kita bisa menambahkan file ke dalamnya! Lanjut ke bagian berikut untuk melihat tiga cara yang dapat digunakan.

##
Menggunakan Antarmuka Web

Antarmuka web menyediakan alat untuk mengelola repositori langsung di Hub. Menggunakan antarmuka ini, Anda dapat dengan mudah membuat repositori, menambahkan file (bahkan file besar!), menjelajahi model, melihat perbedaan file, dan banyak lagi.

Untuk membuat repositori baru, kunjungi huggingface.co/new:

Pertama, tentukan pemilik repositori: ini bisa Anda sendiri atau salah satu organisasi tempat Anda tergabung. Jika Anda memilih organisasi, model tersebut akan tampil di halaman organisasi dan setiap anggota organisasi dapat berkontribusi ke repositori tersebut.

Selanjutnya, masukkan nama model Anda. Ini juga akan menjadi nama repositorinya. Terakhir, Anda bisa menentukan apakah model akan bersifat publik atau privat. Model privat tidak terlihat oleh publik.

Setelah repositori model Anda dibuat, Anda akan melihat halaman seperti ini:

Inilah tempat model Anda akan di-host. Untuk mulai mengisinya, Anda bisa menambahkan file README langsung dari antarmuka web.

File README menggunakan format Markdown — silakan berkreasi sesuka hati! Bagian ketiga dari bab ini akan membahas cara membuat model card. Ini sangat penting untuk memberikan konteks dan nilai terhadap model Anda, karena di sinilah Anda menjelaskan kepada orang lain tentang kegunaan model Anda.

Jika Anda melihat tab “Files and versions”, Anda akan melihat bahwa file yang ada belum banyak — hanya README.md yang baru Anda buat dan file .gitattributes yang mencatat file besar.

Selanjutnya kita akan melihat bagaimana menambahkan file baru.

##
Mengunggah File Model

Sistem untuk mengelola file di Hugging Face Hub berbasis git untuk file reguler, dan git-lfs (Git Large File Storage — lihat situs resmi) untuk file yang lebih besar.

Di bagian berikut, kita akan membahas tiga cara berbeda untuk mengunggah file ke Hub: menggunakan `huggingface_hub` dan perintah git.

###
Pendekatan upload_file

Menggunakan `upload_file` tidak membutuhkan instalasi git atau git-lfs di sistem Anda. File dikirim langsung ke 🤗 Hub melalui permintaan HTTP POST. Namun, metode ini tidak dapat menangani file yang lebih besar dari 5GB.

Jika file Anda lebih besar dari 5GB, gunakan dua metode lainnya yang dijelaskan di bawah.

Contoh penggunaannya:

    from huggingface_hub import upload_file

    upload_file(
        "<path_to_file>/config.json",
        path_in_repo="config.json",
        repo_id="<namespace>/dummy-model",
    )

Ini akan mengunggah file `config.json` dari `<path_to_file>` ke repositori `dummy-model`, disimpan di root dengan nama `config.json`.

Argumen tambahan yang berguna:

- `token`, untuk mengganti token di cache dengan token tertentu.
- `repo_type`, jika Anda ingin mengunggah ke `dataset` atau `space` alih-alih model. Nilai yang diterima: `"dataset"` dan `"space"`.

###
Kelas Repository

Kelas `Repository` digunakan untuk mengelola repositori lokal dengan cara mirip git. Kelas ini menyederhanakan banyak kerumitan penggunaan git dan memberikan semua fitur yang kita butuhkan.

Penggunaan kelas ini memerlukan instalasi `git` dan `git-lfs`. Pastikan Anda telah menginstalnya terlebih dahulu (lihat di sini untuk petunjuk instalasi).

Untuk mulai menggunakan repositori yang baru saja kita buat, kita mulai dengan menginisialisasi folder lokal dengan mengkloning repositori:

    from huggingface_hub import Repository

    repo = Repository("<path_to_dummy_folder>", clone_from="<namespace>/dummy-model")

Ini akan membuat folder `<path_to_dummy_folder>` di direktori kerja kita. Folder tersebut hanya berisi file `.gitattributes`, karena hanya itu yang dibuat saat repositori diinisialisasi.

Mulai dari sini, kita dapat menggunakan beberapa metode git tradisional:

    repo.git_pull()
    repo.git_add()
    repo.git_commit()
    repo.git_push()
    repo.git_tag()

Dan lainnya! Kami menyarankan Anda untuk melihat dokumentasi `Repository` di sini untuk gambaran semua metode yang tersedia.

Saat ini, kita memiliki model dan tokenizer yang ingin kita unggah ke hub. Karena repositori telah berhasil dikloning, kita dapat menyimpan file ke dalam folder tersebut.

Pertama, pastikan salinan lokal kita sudah yang terbaru:

    repo.git_pull()

Setelah itu, simpan file model dan tokenizer:

    model.save_pretrained("<path_to_dummy_folder>")
    tokenizer.save_pretrained("<path_to_dummy_folder>")

Folder `<path_to_dummy_folder>` kini berisi semua file model dan tokenizer. Kita lanjutkan dengan alur kerja git biasa: menambahkan file, melakukan commit, dan mendorong ke hub:

    repo.git_add()
    repo.git_commit("Add model and tokenizer files")
    repo.git_push()

Selamat! Anda baru saja mengunggah file pertama Anda ke hub.

###
Pendekatan berbasis git

Ini adalah pendekatan paling dasar untuk mengunggah file: menggunakan git dan git-lfs secara langsung. Meskipun pendekatan sebelumnya menyederhanakan prosesnya, masih ada beberapa hal penting yang perlu diperhatikan jika menggunakan metode ini.

Gunakan metode ini hanya jika Anda telah menginstal `git` dan `git-lfs`. Pastikan `git-lfs` telah terinstal dan dikonfigurasi dengan benar (lihat di sini untuk petunjuk).

Mulailah dengan menginisialisasi git-lfs:

    git lfs install

    Updated git hooks.
    Git LFS initialized.

Setelah selesai, langkah pertama adalah mengkloning repositori model Anda:

    git clone https://huggingface.co/<namespace>/<your-model-id>

Contoh: nama pengguna saya adalah `lysandre` dan nama model saya adalah `dummy`, maka perintahnya:

    git clone https://huggingface.co/lysandre/dummy

Sekarang saya memiliki folder bernama dummy di direktori kerja. Saya bisa masuk ke folder itu dan melihat isinya:

    cd dummy && ls

    README.md

Jika Anda baru saja membuat repositori menggunakan metode `create_repo` dari Hugging Face Hub, folder ini seharusnya hanya berisi file tersembunyi `.gitattributes`. Jika Anda mengikuti instruksi pada bagian sebelumnya untuk membuat repositori melalui antarmuka web, folder ini seharusnya berisi satu file README.md bersama file tersembunyi `.gitattributes`, seperti yang ditunjukkan di sini.

Menambahkan file berukuran kecil, seperti file konfigurasi, file kosakata, atau file apa pun yang ukurannya hanya beberapa megabyte, dapat dilakukan dengan cara biasa dalam sistem berbasis Git. Namun, file yang lebih besar harus didaftarkan menggunakan git-lfs agar dapat dikirim ke huggingface.co.

Mari kembali ke Python sebentar untuk menghasilkan model dan tokenizer yang ingin kita commit ke repositori dummy kita:

    from transformers import AutoModelForMaskedLM, AutoTokenizer

    checkpoint = "camembert-base"

    model = AutoModelForMaskedLM.from_pretrained(checkpoint)
    tokenizer = AutoTokenizer.from_pretrained(checkpoint)

    # Lakukan apa pun dengan modelnya, latih, fine-tune, dll...

    model.save_pretrained("<path_to_dummy_folder>")
    tokenizer.save_pretrained("<path_to_dummy_folder>")

Sekarang kita telah menyimpan artefak model dan tokenizer, mari kita lihat kembali isi folder dummy:

    ls

    config.json  pytorch_model.bin  README.md  sentencepiece.bpe.model  special_tokens_map.json tokenizer_config.json  tokenizer.json

Jika Anda melihat ukuran file (misalnya dengan `ls -lh`), Anda akan melihat bahwa file pytorch_model.bin adalah pengecualian, karena ukurannya lebih dari 400 MB.

✏️ Saat membuat repositori dari antarmuka web, file *.gitattributes* secara otomatis dikonfigurasi untuk mengenali file dengan ekstensi tertentu, seperti *.bin* dan *.h5*, sebagai file besar. Dengan begitu, git-lfs akan langsung melacak file tersebut tanpa perlu pengaturan tambahan.

Sekarang kita bisa lanjut dan bekerja seperti biasa pada repositori Git. Kita bisa menambahkan semua file ke staging area Git menggunakan perintah `git add`:

    git add .

Kita kemudian bisa melihat file yang sudah distaging:

    git status

    On branch main
    Your branch is up to date with 'origin/main'.

    Changes to be committed:
      (use "git restore --staged <file>..." to unstage)
      modified:   .gitattributes
    	new file:   config.json
    	new file:   pytorch_model.bin
    	new file:   sentencepiece.bpe.model
    	new file:   special_tokens_map.json
    	new file:   tokenizer.json
    	new file:   tokenizer_config.json

Kita juga bisa memastikan bahwa git-lfs melacak file yang benar dengan perintah `git lfs status`:

    git lfs status

    On branch main
    Objects to be pushed to origin/main:

    Objects to be committed:

    	config.json (Git: bc20ff2)
    	pytorch_model.bin (LFS: 35686c2)
    	sentencepiece.bpe.model (LFS: 988bc5a)
    	special_tokens_map.json (Git: cb23931)
    	tokenizer.json (Git: 851ff3e)
    	tokenizer_config.json (Git: f0f7783)

    Objects not staged for commit:

Kita dapat melihat bahwa semua file menggunakan handler `Git`, kecuali pytorch_model.bin dan sentencepiece.bpe.model, yang menggunakan `LFS`. Bagus!

Mari lanjutkan ke langkah terakhir: commit dan push ke repositori huggingface.co:

    git commit -m "First model version"

    [main b08aab1] First model version
     7 files changed, 29027 insertions(+)
      6 files changed, 36 insertions(+)
     create mode 100644 config.json
     create mode 100644 pytorch_model.bin
     create mode 100644 sentencepiece.bpe.model
     create mode 100644 special_tokens_map.json
     create mode 100644 tokenizer.json
     create mode 100644 tokenizer_config.json

Proses push mungkin memakan waktu, tergantung pada kecepatan koneksi internet dan ukuran file Anda:

    git push

    Uploading LFS objects: 100% (1/1), 433 MB | 1.3 MB/s, done.
    Enumerating objects: 11, done.
    Counting objects: 100% (11/11), done.
    Delta compression using up to 12 threads
    Compressing objects: 100% (9/9), done.
    Writing objects: 100% (9/9), 288.27 KiB | 6.27 MiB/s, done.
    Total 9 (delta 1), reused 0 (delta 0), pack-reused 0
    To https://huggingface.co/lysandre/dummy
       891b41d..b08aab1  main -> main

Jika kita melihat repositori model setelah proses ini selesai, kita dapat melihat semua file yang baru saja ditambahkan:

Antarmuka pengguna memungkinkan Anda menjelajahi file model, commit, dan melihat perbedaan (diff) yang diperkenalkan oleh setiap commit:

< > Update on GitHub