Încărcarea modelelor

Transformers oferă multe modele pre-antrenate gata de utilizare cu o singură linie de cod. Acestea necesită o clasă de model și metoda from_pretrained().

Apelează from_pretrained() pentru a descărca și încărca weights și configurația unui model stocate pe Hub-ul Hugging Face.

Metoda from_pretrained() încarcă weights stocate în formatul de fișier safetensors dacă sunt disponibile. În mod tradițional, weights modelelor PyTorch sunt serializate cu utilitarul pickle care este cunoscut ca nesecurizat. Fișierele safetensors sunt mai sigure și mai rapid de încărcat.

from transformers import AutoModelForCausalLM

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

Acest ghid explică cum sunt încărcate modelele, diferitele moduri de a încărca un model, cum să depășești problemele de memorie pentru modele foarte mari și cum să încarci modele personalizate.

Modele și configurații

Toate modelele au un fișier configuration.py cu atribute specifice precum numărul de hidden layers, dimensiunea vocabularului, funcția de activare și altele. Vei găsi și un fișier modeling.py care definește layers și operațiile matematice din interiorul fiecărui strat. Fișierul modeling.py preia atributele modelului din configuration.py și construiește modelul corespunzător. În acest moment, ai un model cu weights aleatorii care trebuie antrenat pentru a produce rezultate semnificative.

O arhitectură se referă la scheletul modelului, iar un checkpoint se referă la weights pentru o anumită arhitectură. De exemplu, [BERT] este o arhitectură, în timp ce google-bert/bert-base-uncased este un checkpoint. Vei vedea termenul model utilizat interschimbabil cu arhitectura și checkpoint-ul.

Există două tipuri generale de modele pe care le poți încărca:

1. Un model de bază, precum AutoModel sau LlamaModel, care returnează hidden states.
2. Un model cu un head specific atașat, precum AutoModelForCausalLM sau LlamaForCausalLM, pentru efectuarea unor task-uri specifice.

Clasele de model

Pentru a obține un model pre-antrenat, trebuie să încarci weights în model. Acest lucru se face apelând from_pretrained() care acceptă weights de pe Hub-ul Hugging Face sau dintr-un folder local.

Există două clase de model: clasa [AutoModel] și o clasă specifică modelului.

from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoModelForQuestionAnswering

# utilizează același API pentru 3 task-uri diferite
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
model = AutoModelForSequenceClassification.from_pretrained("meta-llama/Llama-2-7b-hf")
model = AutoModelForQuestionAnswering.from_pretrained("meta-llama/Llama-2-7b-hf")

from transformers import AutoModelForCausalLM

# utilizează același API pentru 3 modele diferite
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1")
model = AutoModelForCausalLM.from_pretrained("google/gemma-7b")

Modele mari

Modelele mari pre-antrenate necesită multă memorie pentru a fi încărcate. Procesul de încărcare implică:

1. crearea unui model cu weights aleatoare
2. încărcarea weights pre-antrenate
3. plasarea weights pre-antrenate pe model

Ai nevoie de suficientă memorie pentru a reține două copii ale weights modelului (aleatoare și pre-antrenate), ceea ce poate să nu fie posibil în funcție de hardware-ul tău. În medii de antrenare distribuită, aceasta este și mai dificilă deoarece fiecare proces încarcă un model pre-antrenat.

Transformers reduce unele dintre aceste provocări legate de memorie prin inițializare rapidă, checkpoint-uri sharded, funcția Big Model Inference din Accelerate și suportul pentru tipuri de date cu mai puțini biți.

Checkpoint-uri sharded

save_pretrained() shardează automat checkpoint-urile mai mari de 50GB. Aceasta menține numărul de shards redus pentru modelele mari și simplifică gestionarea fișierelor.

Parametrii se încarcă în paralel și vârful de memorie depinde doar de dimensiunea modelului. Utilizează max_shard_size în save_pretrained() pentru a seta dimensiunea maximă a checkpoint-ului înainte de sharding.

Utilizarea memoriei pentru modelele care necesită conversie dinamică de weights depinde de dimensiunea modelului și de dimensiunea celor mai mari parametri dintr-o singură conversie. Aceasta se aplică de obicei modelelor mixture-of-experts (MoE) unde utilizarea memoriei este dimensiunea modelului plus numărul de experți de pe un strat. Consultă ghidul încărcarea dinamică a modelelor pentru a afla mai multe despre cum sunt încărcate modelele.

save_pretrained() creează și un fișier index care mapează numele parametrilor la fișierele lor de shard. Index-ul conține două chei, metadata și weight_map.

import json

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 stochează dimensiunea totală a modelului.

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

weight_map mapează fiecare parametru la fișierul său de shard.

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',
 ...
}

Big Model Inference

Asigură-te că ai Accelerate v0.9.0 și PyTorch v1.9.0 sau o versiune mai nouă instalate pentru a utiliza această funcție!

from_pretrained() este potențat cu funcția Big Model Inference din Accelerate.

Big Model Inference creează un schelet de model pe dispozitivul meta PyTorch. Dispozitivul meta nu stochează date reale, doar metadata.

Weights inițializate aleatoriu sunt create doar când sunt încărcate weights pre-antrenate, pentru a evita menținerea în memorie a două copii ale modelului în același timp. Utilizarea maximă a memoriei este doar dimensiunea modelului.

Află mai multe despre plasarea pe dispozitive în Designing a device map.

A doua funcție a Big Model Inference se referă la modul în care weights sunt încărcate și distribuite în scheletul modelului. Weights modelului sunt distribuite pe toate dispozitivele disponibile, începând cu cel mai rapid dispozitiv (de obicei GPU) și descărcând ulterior weights rămase pe dispozitive mai lente (CPU și hard disk).

Ambele funcții combinate reduc utilizarea memoriei și timpii de încărcare pentru modelele mari pre-antrenate.

Setează device_map la "auto" pentru a activa Big Model Inference.

from transformers import AutoModelForCausalLM

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

Poți, de asemenea, să atribui manual straturi unui dispozitiv în device_map. Ar trebui să mapeze toți parametrii modelului la un dispozitiv, dar nu trebuie să detaliezi unde merg toate sub-modulele unui strat dacă întregul strat se află pe același dispozitiv.

Accesează atributul hf_device_map pentru a vedea cum este distribuit un model pe dispozitive.

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

Tipul de date al modelului

Argumentul dtype controlează dtype-ul PyTorch utilizat pentru a instanția weights modelului. În mod implicit, Transformers încarcă weights cu valoarea dtype sau a moștenitorului torch_dtype din config.json. Dacă config.json nu include niciuna dintre aceste valori, Transformers utilizează dtype-ul primului weight în virgulă mobilă din checkpoint.

Suprascrie valoarea implicită pasând un dtype specific.

import torch
from transformers import AutoModelForCausalLM

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

AutoConfig acceptă de asemenea dtype pentru modelele instanțiate de la zero.

import torch
from transformers import AutoConfig, AutoModel

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

Modele personalizate

Modelele personalizate se construiesc pe clasele de configurație și modelare ale Transformers, suportă API-ul AutoClass și sunt încărcate cu from_pretrained(). Diferența este că codul de modelare nu provine din Transformers.

Fii atent la încărcarea unui model personalizat. Deși Hub-ul include scanare de malware pentru fiecare repository, trebuie totuși să fii atent să nu execuți accidental cod malițios.

Setează trust_remote_code=True în from_pretrained() pentru a încărca un model personalizat.

from transformers import AutoModelForImageClassification

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

Ca un nivel suplimentar de securitate, încarcă un model personalizat dintr-o revizuire specifică pentru a evita încărcarea codului de model care ar putea fi schimbat. Hash-ul commit-ului poate fi copiat din istoricul commit-urilor modelului.

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

Consultă ghidul Personalizarea modelelor pentru mai multe informații.