Accelerate documentation

Büyük modelleri belleğe yükleme

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Büyük modelleri belleğe yükleme

PyTorch'ta önceden eğitilmiş bir model yüklerken, standart iş akışı şu şekildedir:

import torch

my_model = ModelClass(...)
state_dict = torch.load(checkpoint_file)
my_model.load_state_dict(state_dict)

Sadece İngilizceyle ifade etmek gerekirse, bu adımlar şunlardır:

  1. Rastgele başlatılmış ağırlıklarla modeli oluşturun
  2. Model ağırlıklarını (genellikle state dict olarak adlandırılan bir sözlükte) diskten yükleyin
  3. Bu ağırlıkları modelin içine yükleyin

Bu yöntem düzenli boyutlu modeller için çok iyi çalışsa da, devasa bir modelle uğraşırken bu iş akışının bazı belirgin kısıtlamaları vardır: 1. adımda, modelin tam bir sürümü RAM'e yüklenir ve ağırlıklar rastgele başlatılır (bu ağırlıklar 3. adımda atılacaktır). 2. adımda, önceden eğitilmiş ağırlıklarla modelin başka bir tam sürümü RAM'e yüklenir. 6 milyar parametreli bir model yüklüyorsanız, bu, modelin her kopyası için 24GB RAM gerektirdiği anlamına gelir, yani toplamda 48GB (yarısı modeli FP16'da yüklemek için).

Bu API oldukça yenidir ve hâlâ deneysel aşamasındadır. Kararlı bir API sunmaya çalışsak da, genel API'nin küçük bazı kısımlarının gelecekte değişmesi mümkündür.

Süreç Nasıl İşler: Kısa Bir Bakış

Süreç Nasıl İşler: Kodla Çalışma

Boş bir model örneği oluşturma

Büyük modellerle çalışmayı kolaylaştırmak için Accelerate'in tanıttığı ilk araç, herhangi bir RAM kullanmadan bir modeli başlatmanıza yardımcı olan ve bu sayede 1. adımın herhangi bir boyuttaki modellerde yapılabilmesini sağlayan init_empty_weights() bağlam yöneticisidir. İşleyişi şöyledir:

from accelerate import init_empty_weights

with init_empty_weights():
    my_model = ModelClass(...)

Örneğin:

with init_empty_weights():
    model = nn.Sequential(*[nn.Linear(10000, 10000) for _ in range(1000)])

100B'den biraz fazla parametreye sahip boş bir model başlatır. Arka planda, bu, PyTorch 1.9'da tanıtılan meta cihazına dayanır. Bağlam yöneticisi altında başlatma sırasında, her parametre oluşturulduğunda anında o cihaza taşınır.

Bu şekilde başlatılmış bir modeli, herhangi bir veri içermediği için doğrudan CPU veya başka bir cihaza taşıyamazsınız. Ayrıca, meta cihazında tüm işlemler desteklenmediğinden, o boş modelle bir ileri geçişin (forward pass) başarısız olması da oldukça olasıdır.

Parçalı denetim noktaları

Modeliniz o kadar büyük olabilir ki, tek bir kopyası bile RAM’e sığmayabilir. Bu, yüklenemeyeceği anlamına gelmez: bir veya birden fazla GPU’nuz varsa, modelinizi depolamak için daha fazla bellek kullanabilirsiniz. Bu durumda, checkpoint’inizin, checkpoint shard olarak adlandırdığımız birden fazla küçük dosyaya bölünmüş olması daha iyidir.

Accelerate, aşağıdaki biçimi takip etmeniz koşuluyla parçalı checkpoint'leri işler: checkpoint'iniz bir klasörde olmalı, kısmi state dict'leri içeren birkaç dosya bulunmalı ve parametre adlarını ağırlıklarını içeren dosyaya eşleyen bir sözlük içeren JSON biçiminde bir index olmalıdır. Modelinizi save_model() ile kolayca parçalayabilirsiniz. Örneğin, şunları içeren bir klasörümüz olabilir:

first_state_dict.bin
index.json
second_state_dict.bin

index.json aşağıdaki dosya olsun:

{
  "linear1.weight": "first_state_dict.bin",
  "linear1.bias": "first_state_dict.bin",
  "linear2.weight": "second_state_dict.bin",
  "linear2.bias": "second_state_dict.bin"
}

ve "linear1.weight" ile "linear1.bias" ağırlıklarını içeren first_state_dict.bin, "linear2.weight" ve "linear2.bias" ağırlıklarını içeren second_state_dict.bin

Ağırlıkların yüklenmesi

Accelerate'in tanıttığı ikinci araç, boş modeliniz içine bir checkpoint yüklemenizi sağlayan load_checkpoint_and_dispatch() fonksiyonudur. Bu, tam checkpoint'leri (tüm state dict'i içeren tek bir dosya) ve parçalı checkpoint'leri destekler. Ayrıca bu ağırlıkları, sahip olduğunuz cihazlar (GPU'lar, CPU RAM) arasında otomatik olarak dağıtır; bu nedenle parçalı bir checkpoint yüklüyorsanız, maksimum RAM kullanımı en büyük parçanın boyutu olacaktır.

Transformers modelleriyle büyük model çıkarımı kullanmak istiyorsanız, bu belgeye göz atın.

Bu yöntemi kullanarak GPT2-1.5B modelini nasıl yükleyebileceğimizi aşağıda gösteriyoruz.

Bu modelin parçalı (sharded) sürümünü indirelim.

pip install huggingface_hub
from huggingface_hub import snapshot_download
checkpoint = "marcsun13/gpt2-xl-linear-sharded"
weights_location = snapshot_download(repo_id=checkpoint)

Modeli başlatmak için minGPT kütüphanesini kullanacağız.

git clone https://github.com/karpathy/minGPT.git
pip install minGPT/
from accelerate import init_empty_weights
from mingpt.model import GPT

model_config = GPT.get_default_config()
model_config.model_type = 'gpt2-xl'
model_config.vocab_size = 50257
model_config.block_size = 1024

with init_empty_weights():
    model = GPT(model_config)

Ardından, az önce indirdiğimiz kontrol noktasını şununla yükleyin:

from accelerate import load_checkpoint_and_dispatch

model = load_checkpoint_and_dispatch(
    model, checkpoint=weights_location, device_map="auto", no_split_module_classes=['Block']
)

device_map="auto" parametresini geçirerek, Accelerate'e modelin her katmanının kullanılabilir kaynaklara göre nereye yerleştirileceğini otomatik olarak belirlemesini söyleriz:

  • öncelikle, GPU(lar)da kullanılabilir maksimum alanı kullanırız
  • hâlâ boş yere ihtiyacımız varsa, kalan ağırlıkları CPU'da saklarız
  • RAM yeterli değilse, kalan ağırlıklar bellek eşlemeli tensörler olarak sabit diske kaydedilir

no_split_module_classes

Bu parametre, "Block" adlı modüllerden bazılarının farklı cihazlar arasında bölünmemesi gerektiğini belirtir. Burada, herhangi bir türde artımsal bağlantı içeren tüm blokları ayarlamanız gerekir.

The device_map

Modelinizin hf_device_map özniteliğine erişerek Accelerate'in seçtiği device_map değerini görebilirsiniz:

model.hf_device_map
{'transformer.wte': 0,
 'transformer.wpe': 0,
 'transformer.drop': 0,
 'transformer.h.0': 0,
 ...
 'transformer.h.21': 0, 
 'transformer.h.22': 1, 
 'transformer.h.23': 1, 
 'transformer.h.24': 1,
 ...
 'transformer.h.47': 1, 
 'transformer.ln_f': 1, 
 'lm_head': 1}

Katmanların kullanması için kendi cihaz haritanızı oluşturmak ve kullanılacak GPU cihazını (bir sayı), "cpu" veya "disk" belirtip bunu iletmek tamamen mümkündür:

device_map = {
    "transformer.wte": "cpu",
    "transformer.wpe": 0,
    "transformer.drop": "cpu",
    "transformer.h.0": "disk"
}

model = load_checkpoint_and_dispatch(
    model, checkpoint=weights_location, device_map=device_map
)

Modeli çalıştırın

Bunu yaptıktan sonra modelimiz artık birkaç cihazda ve belki de sabit diskte dağılmış durumda. Ancak yine de normal bir PyTorch modeli olarak kullanılabilir:

from mingpt.bpe import BPETokenizer
tokenizer = BPETokenizer()
inputs = tokenizer("Hello, my name is").to(0)

outputs = model.generate(x1, max_new_tokens=10, do_sample=False)[0]
tokenizer.decode(outputs.cpu().squeeze())

Arka planda, Accelerate modele kanca (hook) ekledi, böylece:

  • her katmanda, girdiler doğru cihaza yerleştirilir (böylece modeliniz birden fazla GPU arasında dağıtılmış olsa bile çalışır)
  • CPU'ya taşınan ağırlıklar için, bunlar ileri geçişten hemen önce bir GPU'ya yerleştirilir ve hemen ardından temizlenir
  • sabit diske aktarılan ağırlıklar için, bunlar RAM'e yüklenir, ileri geçişten hemen önce GPU'ya konumlandırılır ve hemen sonrasında temizlenir

Bu sayede, modeliniz bir GPU’ya veya CPU RAM’ine sığmasa bile çıkarım için çalışabilir!

Bu, yalnızca modelinizin çıkarımını (inference) destekler, eğitimini değil. Hesaplamaların çoğu, ara aktivasyonlar nedeniyle GPU belleği harcamamak için torch.no_grad() bağlam yöneticileri (context managers) arkasında gerçekleşir.

Bir cihaz haritası tasarlamak

device_map parametresini desteklenen seçeneklerden birine ("auto", "balanced", "balanced_low_0", "sequential") ayarlayarak Accelerate'ın cihaz haritası hesaplamasını üstlenmesini sağlayabilir veya her katmanın nereye yerleştirileceği üzerinde daha fazla kontrol istiyorsanız haritayı kendiniz oluşturabilirsiniz.

Modelin tüm boyutlarını (ve dolayısıyla bir device_map hesaplayarak) meta cihazda bulunan bir modelden türetebilirsiniz.

Yeterli GPU belleğiniz yoksa (yani GPU’ya sığabilen her şeyi GPU’ya yerleştirip, RAM yetersizse ağırlıkları CPU’ya veya hatta diske taşımak) tüm seçenekler aynı sonucu verecektir.

Model boyutundan daha fazla GPU belleğiniz olduğunda, her seçeneğin farkı şudur:

  • "auto" ve "balanced" seçenekleri, modeli tüm kullanılabilir GPU'lara eşit olarak dağıtır; bu sayede 1'den büyük bir batch boyutu kullanabilirsiniz.
  • "balanced_low_0", ilk GPU hariç tüm GPU'lara modeli eşit olarak dağıtır ve yalnızca diğerlerine sığmayan kısmı GPU 0'a yerleştirir. Bu seçenek, çıktıların işlenmesi için GPU 0'ın kullanılmasının gerektiği durumlarda, örneğin Transformers modelleri için generate işlevinin kullanıldığı senaryolarda mükemmeldir.
  • "sequential", GPU 0’a sığdırabildiği kadarını yerleştirir, ardından GPU 1’e geçer ve böyle devam eder (gerekmeyen durumlarda son GPU’ları kullanmaz).

"auto" ve "balanced" seçenekleri şu an için aynı sonuçları üretir, ancak daha mantıklı bir strateji bulursak "auto" seçeneğinin davranışı gelecekte değişebilir, oysa "balanced" seçeneği kararlı kalacaktır.

Öncelikle, infer_auto_device_map() ve bunu kullanan tüm işlevlerde mevcut olan max_memory argümanını kullanarak her GPU'da kullanılan belleği sınırlayabileceğinizi belirtmek isteriz. max_memory ayarlanırken, GPU tanımlayıcılarını (örneğin 0, 1 vb.) ve CPU offload için kullanmak istediğiniz maksimum RAM için "cpu" anahtarını içeren bir sözlük geçmelisiniz. Değerler, bayt cinsinden bir tamsayı veya "10GiB" ya da "10GB" gibi birimleriyle birlikte bir sayıyı temsil eden bir dize olabilir.

İki GPU’nun her birinde 10GiB’ten fazla ve model ağırlıkları için CPU RAM’inde 30GiB’ten fazla yer kullanmak istemediğimiz bir örnek:

from accelerate import infer_auto_device_map

device_map = infer_auto_device_map(my_model, max_memory={0: "10GiB", 1: "10GiB", "cpu": "30GiB"})

PyTorch'ta ilk atama yapıldığında, GPU'ya bağlı olarak yaklaşık 1-2 GB bellek kullanan CUDA çekirdekleri yüklenir. Bu nedenle, GPU'nun gerçek boyutundan her zaman daha az kullanılabilir belleğe sahip olursunuz. Gerçekte ne kadar bellek kullanıldığını görmek için torch.ones(1).cuda() komutunu çalıştırın ve bellek kullanımına bakın.

Dolayısıyla max_memory ile bellek haritaları oluştururken, bellek dışı (out-of-memory) hatalarını önlemek için kullanılabilir belleği buna göre ayarlamayı unutmayın.

Ayrıca, çıktılarınızı CPU'ya geri yerleştirmeden bazı ek işlemler gerçekleştirirseniz (örneğin Transformers'ın generate yönteminin içinde) ve girdilerinizi bir GPU'ya yerleştirdiyseniz, bu GPU diğerlerinden daha fazla bellek tüketir (Accelerate, çıktıyı her zaman girdinin bulunduğu cihaza geri yerleştirir). Bu nedenle, maksimum batch boyutunu optimize etmek istiyorsanız ve birçok GPU'nuz varsa, ilk GPU'ya daha az bellek atayın. Örneğin, 8x80 A100 kurulumunda BLOOM-176B için ideale yakın harita şudur:

max_memory = {0: "30GIB", 1: "46GIB", 2: "46GIB", 3: "46GIB", 4: "46GIB", 5: "46GIB", 6: "46GIB", 7: "46GIB"}

gördüğünüz gibi, GPU 0'a kıyasla kalan 7 GPU'ya yaklaşık %50 daha fazla bellek ayırdık.

device_map’i tamamen kendiniz tasarlamayı seçerseniz, bu sözlük, anahtarları modelinizin modül adları, değerleri ise geçerli bir cihaz tanımlayıcısı (örneğin GPU’lar için bir tamsayı) veya CPU offload için "cpu", disk offload için "disk" olmalıdır. Anahtarlar modelin tamamını kapsamalıdır; ardından cihaz haritanızı dilediğiniz gibi tanımlayabilirsiniz: örneğin, modelinizde iki blok (diyelim ki block1 ve block2) ve her birinde üç lineer katman (diyelim ki linear1, linear2 ve linear3) varsa, geçerli bir cihaz haritası şun olabilir:

device_map = {"block1": 0, "block2": 1}

Geçerli olabilecek başka bir örnek şudur:

device_map = {"block1": 0, "block2.linear1": 0, "block2.linear2": 1, "block2.linear3": 1}

Öte yandan, bu geçerli değildir çünkü modelin her parametresini kapsamaz:

device_map = {"block1": 0, "block2.linear1": 1, "block2.linear2": 1}

En verimli sonucu almak için, cihaz haritanızın parametreleri GPU'larda sıralı bir şekilde yerleştirdiğinden emin olun (ör. ilk ağırlıklardan birini GPU 0'a, ardından ağırlıkları GPU 1'e ve son ağırlığı tekrar GPU 0'a yerleştirmeyin) böylece GPU'lar arasında çok fazla veri aktarımı yapılmasını önleyin.

Sadece CPU'ya taşıma

Modelinizi CPU'ya taşımak istiyorsanız cpu_offload() kullanabilirsiniz. Sonuç olarak, modelin tüm parametreleri taşınacak ve modelin state dict'inden yalnızca bir kopya tutulacaktır. İleri geçiş sırasında parametreler bu state dict'ten çıkarılacak, çalışma cihazına yerleştirilecek ve ihtiyaç duyuldukça geçirilecek, ardından tekrar taşınacaktır.

cpu_offload(model, execution_device)

cpu_offload_with_hook() işlevini de kullanabilirsiniz. Bu işlev, modeli CPU'ya taşır ve çalıştırıldığında çalışma cihazına geri koyar. cpu_offload() ile farkı, modelin forward işleminden sonra çalışma cihazında kalması ve yalnızca döndürülen hook'un offload yöntemi çağrıldığında yeniden taşınmasıdır. Ayrıca cpu_offload_with_hook() daha performanslıdır ancak daha az bellek tasarrufu sağlar. Bir modeli döngü içinde çalıştıran pipeline'lar için faydalıdır:

model_1, hook_1 = cpu_offload_with_hook(model_1, execution_device)
model_2, hook_2 = cpu_offload_with_hook(model_2, execution_device, prev_module_hook=hook_1)
model_3, hook_3 = cpu_offload_with_hook(model_3, execution_device, prev_module_hook=hook_2)

hid_1 = model_1(input)
for i in range(50):
    # model1 is offloaded on the CPU at the first iteration, model 2 stays on the GPU for this whole loop.
    hid_2 = model_2(hid_1)
# model2 is offloaded to the CPU just before this forward.
hid_3 = model_3(hid_3)

# For model3, you need to manually call the hook offload method.
hook_3.offload()

Sadece disk offload

Disk offload işlemi için disk_offload() kullanabilirsiniz. Sonuç olarak, modelin tüm parametreleri, verilen bir klasörde bellek eşlemeli dizi (memory-mapped array) olarak dışa aktarılır. İleri geçiş (forward pass) sırasında parametrelere bu klasörden erişilir ve ihtiyaç duyuldukça olduğu gibi çalışma cihazına (execution device) aktarılır, ardından tekrar dışa aktarılır.

disk_offload(model, offload_dir, execution_device)

Sınırlar ve ileri geliştirme

API'deki mevcut kısıtlamaların farkındayız:

  • infer_auto_device_map() (veya load_checkpoint_and_dispatch() içindeki device_map="auto") çalıştırıldığında gördüğü kullanılabilir GPU ve CPU RAM miktarını en üst düzeye çıkarmaya çalışır. PyTorch, GPU RAM’ini verimli bir şekilde yönetmekte (ve gerekmediğinde geri vermekte) çok başarılı olsa da, Python ve CPU RAM için bu durum tamamen geçerli değildir. Bu nedenle, otomatik olarak hesaplanan bir cihaz haritası CPU için fazla yoğun olabilir. RAM yetersizliği nedeniyle çökmeler alırsanız, birkaç modülü disk cihazına taşıyın.
  • infer_auto_device_map() (veya load_checkpoint_and_dispatch() içindeki device_map="auto") cihazları sırayla atar (şeyleri ileri geri taşımaktan kaçınmak için) bu yüzden ilk katmanınız sahip olduğunuz GPU boyutundan büyükse, her şey CPU/Disk üzerinde kalır.
  • load_checkpoint_and_dispatch() ve load_checkpoint_in_model() şu anda state dict'inizin modelinizle karşılaştırıldığında doğruluğu üzerinde herhangi bir kontrol yapmaz (bu, gelecekteki bir sürümde düzeltilecektir); bu nedenle, eşleşmeyen veya eksik anahtarlar içeren bir checkpoint yüklemeye çalışırsanız bazı garip hatalarla karşılaşabilirsiniz.
  • Modeliniz birden fazla GPU arasında bölündüğünde kullanılan model paralelliği basit ve optimize edilmemiş olup, bu da belirli bir anda yalnızca bir GPU'nun çalıştığını ve diğerinin boşta beklediği anlamına gelir.
  • Ağırlıklar CPU/sabit diske aktarıldığında, önceden yükleme (pre-fetching) yapılmaz (henüz, gelecek sürümler için bu üzerinde çalışacağız). Bu da ağırlıkların, ihtiyaç duyulmadan önce değil, ihtiyaç duyulduğunda GPU'ya yüklendiği anlamına gelir.
  • Donanımınız disk ile CPU arasında hızlı bir iletişime (NVMES gibi) sahip değilse, sabit disk dışa aktarma işlemi çok yavaş olabilir.
Update on GitHub