Memuat model

Transformers menyediakan banyak model pretrained yang siap digunakan dengan satu baris kode. Hal ini memerlukan kelas model dan metode from_pretrained().

Panggil from_pretrained() untuk mengunduh dan memuat bobot serta konfigurasi model yang disimpan di Hub Hugging Face.

Metode from_pretrained() memuat bobot yang disimpan dalam format file safetensors jika tersedia. Secara tradisional, bobot model PyTorch diserialisasi dengan utilitas pickle yang diketahui tidak aman. File Safetensor lebih aman dan lebih cepat untuk dimuat.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", device_map="auto")

Panduan ini menjelaskan bagaimana model dimuat, berbagai cara untuk memuat model, cara mengatasi masalah memori untuk model yang sangat besar, dan cara memuat model kustom.

Model dan konfigurasi

Semua model memiliki file configuration.py dengan atribut spesifik seperti jumlah lapisan tersembunyi, ukuran kosakata, fungsi aktivasi, dan lainnya. Anda juga akan menemukan file modeling.py yang mendefinisikan lapisan dan operasi matematika yang terjadi di dalam setiap lapisan. File modeling.py mengambil atribut model dari configuration.py dan membangun model sesuai dengan atribut tersebut. Pada tahap ini, Anda memiliki model dengan bobot acak yang perlu dilatih agar menghasilkan output yang bermakna.

Arsitektur merujuk pada kerangka model, sedangkan checkpoint merujuk pada bobot model untuk arsitektur tertentu. Sebagai contoh, BERT adalah sebuah arsitektur, sementara google-bert/bert-base-uncased adalah sebuah checkpoint. Anda akan melihat istilah model digunakan secara bergantian dengan arsitektur dan checkpoint.

Terdapat dua jenis model umum yang dapat dimuat:

Model dasar, seperti AutoModel atau LlamaModel, yang menghasilkan hidden states.
Model dengan head tertentu yang terpasang, seperti AutoModelForCausalLM atau LlamaForCausalLM, untuk menjalankan tugas-tugas tertentu.

Kelas model

Untuk mendapatkan model pretrained, Anda perlu memuat bobot ke dalam model. Hal ini dilakukan dengan memanggil from_pretrained() yang menerima bobot dari Hugging Face Hub atau direktori lokal.

Terdapat dua kelas model, yaitu kelas AutoModel dan kelas yang spesifik untuk model tertentu.

AutoModel

kelas spesifik model

Model besar

Model pretrained yang besar membutuhkan banyak memori untuk dimuat. Proses pemuatan melibatkan:

membuat model dengan bobot acak
memuat bobot terlatih sebelumnya
menempatkan bobot terlatih pada model

Anda membutuhkan cukup memori untuk menyimpan dua salinan bobot model (acak dan pretrained), yang mungkin tidak memungkinkan tergantung pada perangkat keras Anda. Dalam lingkungan pelatihan terdistribusi, hal ini bahkan lebih menantang karena setiap proses memuat model pretrained.

Transformers mengurangi beberapa tantangan terkait memori ini dengan inisialisasi cepat, checkpoint terbagi, fitur Big Model Inference dari Accelerate, serta dukungan untuk tipe data bit yang lebih rendah.

Checkpoint terpecah

save_pretrained() secara otomatis memecah checkpoint yang ukurannya lebih dari 50GB. Hal ini menjaga jumlah shard tetap rendah untuk model besar dan menyederhanakan pengelolaan file.

Parameter dimuat secara paralel dan memori puncak hanya bergantung pada ukuran model. Gunakan max_shard_size di save_pretrained() untuk mengatur ukuran checkpoint maksimum sebelum sharding.

Pemakaian memori untuk model yang memerlukan konversi bobot dinamis bergantung pada ukuran model dan ukuran parameter terbesar dalam satu konversi. Hal ini biasanya berlaku untuk model mixture-of-experts (MoE), di mana pemakaian memori adalah ukuran model ditambah jumlah ahli pada satu lapisan. Lihat panduan dynamic weight loader untuk mempelajari lebih lanjut tentang cara model dimuat.

save_pretrained() juga membuat file indeks yang memetakan nama parameter ke file shard-nya. Indeks tersebut berisi dua kunci, yaitu metadata dan weight_map.

import json
import os
import tempfile

with tempfile.TemporaryDirectory() as tmp_dir:
    model.save_pretrained(tmp_dir, max_shard_size="50GB")
    with open(os.path.join(tmp_dir, "model.safetensors.index.json"), "r") as f:
        index = json.load(f)

print(index.keys())

metadata menyimpan ukuran total model.

index["metadata"]
{'total_size': 28966928384}

weight_map memetakan setiap parameter ke file shard-nya.

index["weight_map"]
{'lm_head.weight': 'model-00006-of-00006.safetensors',
 'model.embed_tokens.weight': 'model-00001-of-00006.safetensors',
 'model.layers.0.input_layernorm.weight': 'model-00001-of-00006.safetensors',
 'model.layers.0.mlp.down_proj.weight': 'model-00001-of-00006.safetensors',
 ...
}

Inferensi Model Besar

Pastikan Anda telah menginstal Accelerate v0.9.0 dan PyTorch v1.9.0 atau yang lebih baru untuk menggunakan fitur ini!

from_pretrained() ditingkatkan dengan fitur Big Model Inference dari Accelerate.

Big Model Inference membuat kerangka model pada perangkat meta PyTorch. Perangkat meta tidak menyimpan data nyata apa pun, hanya metadata.

Bobot yang diinisialisasi secara acak hanya dibuat saat bobot pretrained dimuat, untuk menghindari pemeliharaan dua salinan model di memori secara bersamaan. Penggunaan memori maksimum hanyalah ukuran model.

Pelajari lebih lanjut tentang penempatan perangkat di Merancang peta perangkat.

Fitur kedua dari Big Model Inference berkaitan dengan cara bobot dimuat dan didistribusikan dalam kerangka model. Bobot model didistribusikan ke semua perangkat yang tersedia, dimulai dari perangkat tercepat (biasanya GPU), lalu bobot yang tersisa dipindahkan ke perangkat yang lebih lambat (CPU dan hard drive).

Kombinasi kedua fitur tersebut mengurangi penggunaan memori dan waktu pemuatan untuk model pretrained berukuran besar.

Setel device_map ke "auto" untuk mengaktifkan Big Model Inference.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("google/gemma-7b", device_map="auto")

Anda juga dapat secara manual menetapkan layer ke perangkat dalam device_map. Peta ini harus memetakan semua parameter model ke perangkat, tetapi Anda tidak perlu merinci ke mana setiap submodule dari sebuah layer ditempatkan jika seluruh layer berada di perangkat yang sama.

Akses atribut hf_device_map untuk melihat bagaimana model didistribusikan di antara perangkat.

device_map = {"model.layers.1": 0, "model.layers.14": 1, "model.layers.31": "cpu", "lm_head": "disk"}
model.hf_device_map

Offloading ke disk

Ketika sebuah model terlalu besar untuk kapasitas gabungan GPU dan RAM CPU Anda, Big Model Inference akan memindahkan sisa bobot ke disk. Atur offload_folder ke sebuah direktori setiap kali ada bobot yang dipetakan ke "disk", karena di situlah Transformers menyimpan bobot yang dipindahkan.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-7b",
    device_map="auto",
    offload_folder="./offload",
)

Gunakan max_memory untuk membatasi jumlah data yang disimpan di setiap perangkat. Transformers mengisi perangkat secara berurutan berdasarkan kecepatan dan mengirim data yang tidak muat ke disk. Contoh di bawah ini membatasi GPU ke 10GB dan CPU ke 30GB, sehingga sisa bobot akan disimpan di offload_folder.

model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-7b",
    device_map="auto",
    max_memory={0: "10GB", "cpu": "30GB"},
    offload_folder="./offload",
)

Setel max_memory={} untuk menentukan bahwa tidak ada memori gpu atau cpu yang tersedia dan untuk memaksa offloading seluruh model ke disk.

model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-7b",
    device_map="auto",
    max_memory={},
    offload_folder="./offload",
)

Disk offloading menukar memori demi kecepatan. Membaca bobot dari disk pada setiap forward pass lebih lambat daripada membaca dari memori CPU atau GPU. Disk offloading penuh memerlukan accelerate>1.14.0

Tipe data model

Argumen dtype mengontrol dtype PyTorch yang digunakan untuk menginisialisasi bobot model. Secara default, Transformers memuat bobot dengan nilai dtype atau torch_dtype lama dari config.json. Jika config.json tidak menyertakan salah satu nilai tersebut, Transformers menggunakan dtype dari bobot floating-point pertama dalam checkpoint.

Override nilai default dengan meneruskan dtype tertentu.

import torch
from transformers import AutoModelForCausalLM

# specific dtype
model = AutoModelForCausalLM.from_pretrained("google/gemma-3-1b-it", dtype=torch.float16)

AutoConfig juga menerima dtype untuk model yang dibuat dari awal.

import torch
from transformers import AutoConfig, AutoModel

my_config = AutoConfig.from_pretrained("google/gemma-2b", dtype=torch.float16)
model = AutoModel.from_config(my_config)

Model kustom

Model kustom dibangun di atas kelas konfigurasi dan pemodelan Transformers, mendukung API AutoClass, dan dimuat dengan from_pretrained(). Perbedaannya adalah kode pemodelannya tidak berasal dari Transformers.

Ambil kehati-hatian ekstra saat memuat model kustom. Meskipun Hub mencakup pemindaian malware untuk setiap repositori, Anda tetap harus berhati-hati untuk menghindari eksekusi kode berbahaya secara tidak sengaja.

Setel trust_remote_code=True di from_pretrained() untuk memuat model kustom.

from transformers import AutoModelForImageClassification

model = AutoModelForImageClassification.from_pretrained("sgugger/custom-resnet50d", trust_remote_code=True)

Sebagai lapisan keamanan tambahan, muat model kustom dari revisi tertentu untuk menghindari pemuatan kode model yang mungkin telah berubah. Hash commit dapat disalin dari riwayat commit model.

commit_hash = "ed94a7c6247d8aedce4647f00f20de6875b5b292"
model = AutoModelForImageClassification.from_pretrained(
    "sgugger/custom-resnet50d", trust_remote_code=True, revision=commit_hash
)

Lihat panduan Customize models untuk informasi lebih lanjut.

Update on GitHub