Accelerate documentation
Büyük modelleri belleğe yükleme
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:
- Rastgele başlatılmış ağırlıklarla modeli oluşturun
- Model ağırlıklarını (genellikle state dict olarak adlandırılan bir sözlükte) diskten yükleyin
- 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_maphesaplayarak) 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çingenerateiş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_memoryile 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.