Hugging Face's logo

Accelerate documentation

Bekerja dengan model besar

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.15.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Bekerja dengan model besar

Dispatch dan offload

init_empty_weights

accelerate.init_empty_weights

< >

( include_buffers: bool | None = None )

Parameter

  • include_buffers (bool, opsional) — Apakah semua buffer juga akan ditempatkan pada perangkat meta selama inisialisasi.

Manajer konteks di mana model diinisialisasi dengan semua parameter pada perangkat meta, sehingga membuat model kosong. Berguna ketika inisialisasi model saja akan menghabiskan RAM yang tersedia.

Contoh:

import torch.nn as nn
from accelerate import init_empty_weights

# Initialize a model with 100 billions parameters in no time and without using any RAM.
with init_empty_weights():
    tst = nn.Sequential(*[nn.Linear(10000, 10000) for _ in range(1000)])

Model apa pun yang dibuat di bawah context manager ini tidak memiliki bobot. Oleh karena itu, Anda tidak dapat melakukan sesuatu seperti model.to(some_device) dengannya. Untuk memuat bobot di dalam model kosong Anda, lihat load_checkpoint_and_dispatch(). Pastikan untuk menimpa param device_map default untuk load_checkpoint_and_dispatch(), jika tidak dispatch tidak dipanggil.

cpu_offload

accelerate.cpu_offload

< >

( model: Moduleexecution_device: torch.device | None = Noneoffload_buffers: bool = Falsestate_dict: dict[str, torch.Tensor] | None = Nonepreload_module_classes: list[str] | None = None )

Parameter

  • model (torch.nn.Module) — Model yang akan di-offload.
  • execution_device (torch.device, opsional) — Perangkat tempat forward pass model akan dieksekusi (seharusnya berupa GPU). Secara default akan menggunakan perangkat parameter pertama model.
  • offload_buffers (bool, opsional, default False) — Apakah buffer akan di-offload bersama parameter model.
  • state_dict (Dict[str, torch.Tensor], opsional) — State dict dari model yang akan disimpan di CPU.
  • preload_module_classes (List[str], opsional) — Daftar kelas yang instansnya harus memuat semua bobotnya (bahkan di submodul) di awal forward. Ini hanya harus digunakan untuk kelas yang memiliki submodul yang terdaftar tetapi tidak dipanggil secara langsung selama forward, misalnya jika lapisan linear dense terdaftar, tetapi saat forward, dense.weight dan dense.bias digunakan dalam beberapa operasi alih-alih memanggil dense secara langsung.

Mengaktifkan offload CPU penuh untuk sebuah model. Akibatnya, semua parameter model akan di-offload dan hanya satu salinan state dict model yang akan disimpan. Selama forward pass, parameter akan diekstrak dari state dict tersebut dan ditempatkan pada perangkat eksekusi yang diberikan sesuai kebutuhan, kemudian di-offload kembali.

cpu_offload_with_hook

accelerate.cpu_offload_with_hook

< >

( model: Moduleexecution_device: int | str | torch.device | None = Noneprev_module_hook: accelerate.hooks.UserCpuOffloadHook | None = None )

Parameter

  • model (torch.nn.Module) — Model yang akan di-offload.
  • execution_device(str, int atau torch.device, opsional) — Perangkat tempat model harus dieksekusi. Secara default akan menggunakan perangkat MPS jika tersedia, kemudian perangkat 0 jika ada perangkat akselerator, dan terakhir CPU.
  • prev_module_hook (UserCpuOffloadHook, opsional) — Hook yang dikembalikan oleh fungsi ini untuk model sebelumnya dalam pipeline yang sedang Anda jalankan. Jika diberikan, metode offload-nya akan dipanggil tepat sebelum forward dari model tempat hook ini terpasang.

Memindahkan model ke CPU dan mengembalikannya ke perangkat eksekusi saat dieksekusi. Perbedaannya dengan cpu_offload() adalah model tetap berada di perangkat eksekusi setelah forward dan hanya dipindahkan kembali ketika metode offload dari hook yang dikembalikan dipanggil. Berguna untuk pipeline yang menjalankan model dalam loop.

Contoh:

model_1, hook_1 = cpu_offload_with_hook(model_1, device)
model_2, hook_2 = cpu_offload_with_hook(model_2, device, prev_module_hook=hook_1)
model_3, hook_3 = cpu_offload_with_hook(model_3, 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()

disk_offload

accelerate.disk_offload

< >

( model: Moduleoffload_dir: str | os.PathLikeexecution_device: torch.device | None = Noneoffload_buffers: bool = Falsepreload_module_classes: list[str] | None = None )

Parameter

  • model (torch.nn.Module) — Model yang akan di-offload.
  • offload_dir (str atau os.PathLike) — Folder tempat bobot model di-offload (atau tempat bobot model sudah di-offload).
  • execution_device (torch.device, opsional) — Perangkat tempat forward pass model akan dieksekusi (seharusnya berupa GPU). Secara default akan menggunakan perangkat parameter pertama model.
  • offload_buffers (bool, opsional, default False) — Apakah buffer akan di-offload bersama parameter model.
  • preload_module_classes (List[str], opsional) — Daftar kelas yang instansnya harus memuat semua bobotnya (bahkan di submodul) di awal forward. Ini hanya harus digunakan untuk kelas yang memiliki submodul yang terdaftar tetapi tidak dipanggil secara langsung selama forward, misalnya jika lapisan linear dense terdaftar, tetapi saat forward, dense.weight dan dense.bias digunakan dalam beberapa operasi alih-alih memanggil dense secara langsung.

Mengaktifkan offload disk penuh untuk sebuah model. Akibatnya, semua parameter model akan di-offload sebagai array memory-mapped di folder yang ditentukan. Selama forward pass, parameter akan diakses dari folder tersebut dan dipindahkan ke perangkat eksekusi yang diberikan sesuai kebutuhan, kemudian di-offload kembali.

dispatch_model

accelerate.dispatch_model

< >

( model: Moduledevice_map: dictmain_device: torch.device | None = Nonestate_dict: dict[str, torch.Tensor] | None = Noneoffload_dir: str | os.PathLike | None = Noneoffload_index: dict[str, str] | None = Noneoffload_buffers: bool = Falseskip_keys: str | list[str] | None = Nonepreload_module_classes: list[str] | None = Noneforce_hooks: bool = False )

Parameter

  • model (torch.nn.Module) — Model yang akan didispatch.
  • device_map (Dict[str, Union[str, int, torch.device]]) — Kamus yang memetakan nama modul dalam state_dict model ke perangkat tempat modul tersebut harus ditempatkan. Perhatikan bahwa "disk" diterima meskipun bukan nilai yang valid untuk torch.device.
  • main_device (str, int atau torch.device, opsional) — Perangkat eksekusi utama. Secara default akan menggunakan perangkat pertama dalam device_map yang berbeda dari "cpu" atau "disk".
  • state_dict (Dict[str, torch.Tensor], opsional) — State dict dari bagian model yang akan disimpan di CPU.
  • offload_dir (str atau os.PathLike) — Folder tempat bobot model di-offload (atau tempat bobot model sudah di-offload).
  • offload_index (Dict, opsional) — Kamus dari nama bobot ke informasinya (dtype/ shape atau nama file safetensors). Secara default akan menggunakan indeks yang disimpan di save_folder.
  • offload_buffers (bool, opsional, default False) — Apakah buffer akan di-offload bersama parameter model.
  • skip_keys (str atau List[str], opsional) — Daftar kunci yang diabaikan saat memindahkan input atau output antar perangkat.
  • preload_module_classes (List[str], opsional) — Daftar kelas yang instansnya harus memuat semua bobotnya (bahkan di submodul) di awal forward. Ini hanya harus digunakan untuk kelas yang memiliki submodul yang terdaftar tetapi tidak dipanggil secara langsung selama forward, misalnya jika lapisan linear dense terdaftar, tetapi saat forward, dense.weight dan dense.bias digunakan dalam beberapa operasi alih-alih memanggil dense secara langsung.
  • force_hooks (bool, opsional, defaultnya False) — Apakah akan memaksa device hooks untuk dilampirkan ke model meskipun semua lapisan didistribusikan ke satu perangkat.

Mendistribusikan model sesuai dengan peta perangkat yang diberikan. Lapisan model dapat tersebar di beberapa GPU, dimuat ulang ke CPU, atau bahkan ke disk.

load_checkpoint_and_dispatch

accelerate.load_checkpoint_and_dispatch

< >

( model: Modulecheckpoint: str | os.PathLikedevice_map: str | dict[str, int | str | torch.device] | None = Nonemax_memory: dict[int | str, int | str] | None = Noneno_split_module_classes: list[str] | None = Noneoffload_folder: str | os.PathLike | None = Noneoffload_buffers: bool = Falsedtype: str | torch.dtype | None = Noneoffload_state_dict: bool | None = Noneskip_keys: str | list[str] | None = Nonepreload_module_classes: list[str] | None = Noneforce_hooks: bool = Falsestrict: bool = Falsefull_state_dict: bool = Truebroadcast_from_rank0: bool = False )

Parameter

  • model (torch.nn.Module) — Model tempat kita ingin memuat checkpoint.
  • checkpoint (str atau os.PathLike) — Checkpoint folder yang akan dimuat. Bisa berupa:
    • path ke file yang berisi state dict model lengkap
    • path ke file .json yang berisi indeks untuk checkpoint yang dipecah
    • path ke folder yang berisi file .index.json unik dan shard dari checkpoint.
  • device_map (Dict[str, Union[int, str, torch.device]], opsional) — Peta yang menentukan ke perangkat mana setiap submodul harus ditempatkan. Peta ini tidak perlu dirinci hingga ke nama parameter/buffer; begitu nama modul tertentu sudah termasuk di dalamnya, semua submodul di bawahnya akan dikirim ke perangkat yang sama.

    Untuk membuat Accelerate menghitung device_map yang paling teroptimasi secara otomatis, atur device_map="auto". Untuk informasi lebih lanjut tentang setiap opsi, lihat di sini. Nilai defaultnya adalah None, yang berarti dispatch_model() tidak akan dipanggil.

  • max_memory (Dict, opsional) — Kamus pengidentifikasi perangkat ke memori maksimum. Jika tidak disetel, nilai defaultnya adalah memori maksimum yang tersedia untuk setiap GPU dan RAM CPU yang tersedia.
  • no_split_module_classes (List[str], opsional) — Daftar nama kelas layer yang tidak boleh dipecah antar perangkat (misalnya layer apa pun yang memiliki koneksi residual).
  • offload_folder (str atau os.PathLike, opsional) — Jika device_map berisi nilai "disk", folder tempat bobot akan di-offload.
  • offload_buffers (bool, opsional, default False) — Pada lapisan yang di-offload ke CPU atau hard drive, apakah buffer juga akan di-offload bersama dengan parameter.
  • dtype (str atau torch.dtype, opsional) — Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat.
  • offload_state_dict (bool, opsional) — Jika True, state dict CPU akan secara sementara di-offload ke hard drive untuk menghindari kehabisan RAM CPU jika berat state dict CPU + shard terbesar tidak muat. Akan default ke True jika device map yang dipilih berisi nilai "disk".
  • skip_keys (str atau List[str], opsional) — Daftar kunci yang diabaikan saat memindahkan input atau output antar perangkat.
  • preload_module_classes (List[str], opsional) — Daftar kelas yang instansnya harus memuat semua bobotnya (bahkan di submodul) di awal forward. Ini hanya harus digunakan untuk kelas yang memiliki submodul yang terdaftar tetapi tidak dipanggil secara langsung selama forward, misalnya jika lapisan linear dense terdaftar, tetapi saat forward, dense.weight dan dense.bias digunakan dalam beberapa operasi alih-alih memanggil dense secara langsung.
  • force_hooks (bool, opsional, defaultnya False) — Apakah akan memaksa device hooks untuk dilampirkan ke model meskipun semua lapisan didistribusikan ke satu perangkat.
  • strict (bool, opsional, defaultnya False) — Apakah akan secara ketat menegakkan bahwa kunci dalam state_dict checkpoint harus cocok dengan kunci dari state_dict model.
  • full_state_dict (bool, opsional, defaultnya True) — jika ini diatur ke True, semua tensor dalam state_dict yang dimuat akan dikumpulkan. Tidak akan ada ShardedTensor dan DTensor dalam state_dict yang dimuat.
  • broadcast_from_rank0 (False, opsional, defaultnya False) — ketika opsi ini True, sebuah ProcessGroup terdistribusi harus diinisialisasi. rank0 harus menerima state_dict lengkap dan akan melakukan broadcast tensor di dalam state_dict satu per satu ke rank lainnya. Rank lainnya akan menerima tensor tersebut dan melakukan sharding (jika berlaku) sesuai dengan shard lokal di model.

Memuat checkpoint (yang mungkin terbagi) di dalam model, dengan kemungkinan mengirim bobot ke perangkat tertentu saat dimuat, serta menambahkan berbagai hook yang akan membuat model ini berjalan dengan benar (bahkan jika terbagi di antara perangkat).

Contoh:

>>> from accelerate import init_empty_weights, load_checkpoint_and_dispatch
>>> from huggingface_hub import hf_hub_download
>>> from transformers import AutoConfig, AutoModelForCausalLM

>>> # Download the Weights
>>> checkpoint = "EleutherAI/gpt-j-6B"
>>> weights_location = hf_hub_download(checkpoint, "pytorch_model.bin")

>>> # Create a model and initialize it with empty weights
>>> config = AutoConfig.from_pretrained(checkpoint)
>>> with init_empty_weights():
...     model = AutoModelForCausalLM.from_config(config)

>>> # Load the checkpoint and dispatch it to the right devices
>>> model = load_checkpoint_and_dispatch(
...     model, weights_location, device_map="auto", no_split_module_classes=["GPTJBlock"]
... )

load_checkpoint_in_model

accelerate.load_checkpoint_in_model

< >

( model: Modulecheckpoint: str | os.PathLikedevice_map: dict[str, int | str | torch.device] | None = Noneoffload_folder: str | os.PathLike | None = Nonedtype: str | torch.dtype | None = Noneoffload_state_dict: bool = Falseoffload_buffers: bool = Falsekeep_in_fp32_modules: list[str] | None = Noneoffload_8bit_bnb: bool = Falsestrict: bool = Falsefull_state_dict: bool = Truebroadcast_from_rank0: bool = False )

Parameter

  • model (torch.nn.Module) — Model tempat kita ingin memuat checkpoint.
  • checkpoint (str atau os.PathLike) — Checkpoint folder yang akan dimuat. Bisa berupa:
    • path ke file yang berisi state dict model lengkap
    • path ke file .json yang berisi indeks untuk checkpoint yang dipecah
    • path ke folder yang berisi file .index.json unik dan shard dari checkpoint.
    • path ke folder yang berisi file pytorch_model.bin atau model.safetensors yang unik.
  • device_map (Dict[str, Union[int, str, torch.device]], opsional) — Peta yang menentukan ke perangkat mana setiap submodul harus ditempatkan. Peta ini tidak perlu dirinci hingga ke nama parameter/buffer; begitu nama modul tertentu sudah termasuk di dalamnya, semua submodul di bawahnya akan dikirim ke perangkat yang sama.
  • offload_folder (str atau os.PathLike, opsional) — Jika device_map berisi nilai "disk", folder tempat bobot akan di-offload.
  • dtype (str atau torch.dtype, opsional) — Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat.
  • offload_state_dict (bool, opsional, default False) — Jika True, state dict CPU akan secara sementara di-offload ke hard drive untuk menghindari kehabisan RAM CPU jika bobot state dict CPU + shard terbesar tidak muat.
  • offload_buffers (bool, opsional, default False) — Apakah buffer akan disertakan dalam bobot yang di-offload ke disk.
  • keep_in_fp32_modules(List[str], opsional) — Daftar modul yang dipertahankan dalam dtype torch.float32.
  • offload_8bit_bnb (bool, opsional) — Apakah akan mengaktifkan offload modul 8-bit ke cpu/disk.
  • strict (bool, opsional, defaultnya False) — Apakah akan secara ketat menegakkan bahwa kunci dalam state_dict checkpoint harus cocok dengan kunci dari state_dict model.
  • full_state_dict (bool, opsional, defaultnya True) — jika ini diatur ke True, semua tensor dalam state_dict yang dimuat akan dikumpulkan. Tidak akan ada ShardedTensor dan DTensor dalam state_dict yang dimuat.
  • broadcast_from_rank0 (False, opsional, defaultnya False) — ketika opsi ini True, sebuah ProcessGroup terdistribusi harus diinisialisasi. rank0 harus menerima state_dict lengkap dan akan melakukan broadcast tensor di dalam state_dict satu per satu ke rank lainnya. Rank lainnya akan menerima tensor tersebut dan melakukan sharding (jika berlaku) sesuai dengan shard lokal di model.

Memuat checkpoint (yang mungkin terbagi) di dalam model, dengan kemungkinan mengirim bobot ke perangkat tertentu saat dimuat.

Setelah dimuat di seluruh perangkat, Anda masih perlu memanggil dispatch_model() pada model Anda agar model tersebut dapat dijalankan. Untuk mengelompokkan pemuatan checkpoint dan dispatch dalam satu panggilan tunggal, gunakan load_checkpoint_and_dispatch().

infer_auto_device_map

accelerate.infer_auto_device_map

< >

( model: Modulemax_memory: dict[int | str, int | str] | None = Noneno_split_module_classes: list[str] | None = Nonedtype: str | torch.dtype | None = Nonespecial_dtypes: dict[str, str | torch.dtype] | None = Noneverbose: bool = Falseclean_result: bool = Trueoffload_buffers: bool = Falsefallback_allocation: bool = False )

Parameter

  • model (torch.nn.Module) — Model yang akan dianalisis.
  • max_memory (Dict, opsional) — Kamus pengidentifikasi perangkat ke memori maksimum. Akan menggunakan memori maksimum yang tersedia jika tidak diatur. Contoh: max_memory={0: "1GB"}.
  • no_split_module_classes (List[str], opsional) — Daftar nama kelas layer yang tidak boleh dipecah antar perangkat (misalnya layer apa pun yang memiliki koneksi residual).
  • dtype (str atau torch.dtype, opsional) — Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat.
  • special_dtypes (Dict[str, Union[str, torch.device]], opsional) — Jika disediakan, dtype khusus yang dipertimbangkan untuk beberapa bobot tertentu (akan menimpa dtype yang digunakan sebagai default untuk semua bobot).
  • verbose (bool, opsional, default False) — Apakah akan memberikan pernyataan debugging saat fungsi membangun device_map.
  • clean_result (bool, opsional, default True) — Bersihkan device_map hasil akhir dengan mengelompokkan semua submodul yang berada di perangkat yang sama.
  • offload_buffers (bool, opsional, default False) — Pada lapisan yang di-offload ke CPU atau hard drive, apakah buffer juga akan di-offload bersama dengan parameter.
  • fallback_allocation (bool, opsional, default False) — Jika alokasi reguler gagal, coba alokasikan modul yang muat dalam batas ukuran menggunakan BFS.

Hitung peta perangkat untuk model tertentu dengan memberikan prioritas pada GPU, kemudian offload ke CPU dan akhirnya offload ke disk, sehingga:

  • kami tidak melebihi memori yang tersedia pada GPU mana pun.
  • jika offload ke CPU diperlukan, selalu ada ruang tersisa di GPU 0 untuk mengembalikan layer yang di-offload ke CPU yang memiliki ukuran terbesar.
  • jika offload ke CPU diperlukan, kami tidak melebihi RAM yang tersedia di CPU.
  • jika offload ke disk diperlukan, selalu ada ruang tersisa di CPU untuk mengembalikan layer yang di-offload ke disk yang memiliki ukuran terbesar.

Semua komputasi dilakukan dengan menganalisis ukuran dan dtype dari parameter model. Akibatnya, model dapat berada pada perangkat meta (seperti yang akan terjadi jika diinisialisasi di dalam context manager init_empty_weights).

Hooks

ModelHook

kelas accelerate.hooks.ModelHook

< >

( )

Hook yang berisi callback untuk dieksekusi tepat sebelum dan sesudah metode forward dari sebuah model. Perbedaannya dengan hook yang sudah ada di PyTorch adalah bahwa hook ini meneruskan kwargs.

Atribut kelas:

  • no_grad (bool, opsional, default False) — Apakah akan mengeksekusi forward pass aktual di bawah context manager torch.no_grad().

detach_hook

< >

( module )

Parameter

  • module (torch.nn.Module) — Modul yang dilepaskan dari hook ini.

Dijalankan saat hook dilepas dari modul.

init_hook

< >

( module )

Parameter

  • module (torch.nn.Module) — Modul yang terlampir pada hook ini.

Untuk dieksekusi saat hook dilampirkan ke modul.

post_forward

< >

( moduleoutput ) → Any

Parameter

  • module (torch.nn.Module) — Modul yang forward pass-nya baru saja dieksekusi sebelum event ini.
  • output (Any) — Output dari modul.

Mengembalikan

Any

output yang telah diproses.

Untuk dieksekusi tepat setelah metode forward dari model.

pre_forward

< >

( module*args**kwargs ) → Tuple[Tuple[Any], Dict[Str, Any]]

Parameter

  • module (torch.nn.Module) — Modul yang jalur forward-nya akan dieksekusi tepat setelah event ini.
  • args (Tuple[Any]) — Argumen posisional yang diteruskan ke modul.
  • kwargs (Dict[Str, Any]) — Argumen kata kunci yang diteruskan ke modul.

Mengembalikan

Tuple[Tuple[Any], Dict[Str, Any]]

Tuple berisi args dan kwargs yang telah diproses.

Untuk dieksekusi tepat sebelum metode forward dari model.

AlignDevicesHook

kelas accelerate.hooks.AlignDevicesHook

< >

( execution_device: int | str | torch.device | None = Noneoffload: bool = Falseio_same_device: bool = Falseweights_map: collections.abc.Mapping | None = Noneoffload_buffers: bool = Falseplace_submodules: bool = Falseskip_keys: str | list[str] | None = Nonetied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None )

Parameter

  • execution_device (torch.device, opsional) — Perangkat tempat input dan bobot model harus ditempatkan sebelum forward pass.
  • offload (bool, opsional, default False) — Apakah bobot harus di-offload setelah forward pass.
  • io_same_device (bool, opsional, default False) — Apakah output harus ditempatkan pada perangkat yang sama dengan input.
  • weights_map (Mapping[str, torch.Tensor], opsional) — Ketika bobot model di-offload, sebuah peta (yang mungkin lazy) dari nama parameter ke nilai tensor.
  • offload_buffers (bool, opsional, defaultnya False) — Apakah akan menyertakan buffer dari modul terkait saat melakukan offloading.
  • place_submodules (bool, opsional, default False) — Apakah menempatkan submodul pada execution_device selama event init_hook.

A generic ModelHook yang memastikan input dan bobot model berada pada perangkat yang sama untuk jalur maju (forward pass) dari modul terkait, dengan kemungkinan melakukan offloading bobot setelah jalur maju.

SequentialHook

kelas accelerate.hooks.SequentialHook

< >

( *hooks )

Hook yang dapat berisi beberapa hook dan mengiterasikannya pada setiap event.

LayerwiseCastingHook

kelas accelerate.hooks.LayerwiseCastingHook

< >

( storage_dtype: dtypecompute_dtype: dtypenon_blocking: bool )

Hook yang mengonversi bobot modul ke dtype presisi tinggi untuk komputasi, dan ke dtype presisi rendah untuk penyimpanan. Proses ini dapat menyebabkan penurunan kualitas pada output, tetapi dapat mengurangi jejak memori secara signifikan.

Menambahkan Hook

add_hook_to_module

accelerate.hooks.add_hook_to_module

< >

( module: Modulehook: ModelHookappend: bool = False ) → torch.nn.Module

Parameter

  • module (torch.nn.Module) — Modul tempat hook akan dilampirkan.
  • hook (ModelHook) — Hook yang akan dilampirkan.
  • append (bool, opsional, defaultnya False) — Apakah hook harus dirangkai dengan hook yang sudah ada (jika modul sudah berisi hook) atau tidak.

Mengembalikan

torch.nn.Module

Modul yang sama, dengan hook yang terpasang (modul dimodifikasi di tempatnya, sehingga hasilnya dapat diabaikan).

Menambahkan hook ke modul tertentu. Hal ini akan menulis ulang metode forward dari modul tersebut untuk menyertakan hook. Untuk menghapus perilaku ini dan memulihkan metode forward asli, gunakan remove_hook_from_module.

Jika modul sudah berisi hook, hook ini akan menggantinya dengan hook baru yang diteruskan secara default. Untuk merangkai dua hook bersama, teruskan append=True, sehingga hook saat ini dan hook baru dirangkai menjadi sebuah instance dari kelas SequentialHook.

attach_execution_device_hook

accelerate.hooks.attach_execution_device_hook

< >

( module: Moduleexecution_device: int | str | torch.deviceskip_keys: str | list[str] | None = Nonepreload_module_classes: list[str] | None = Nonetied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None )

Parameter

  • module (torch.nn.Module) — Modul tempat kita ingin menempelkan hook.
  • execution_device (int, str atau torch.device) — Perangkat tempat input dan bobot model harus ditempatkan sebelum forward pass.
  • skip_keys (str atau List[str], opsional) — Daftar kunci yang diabaikan saat memindahkan input atau output antar perangkat.
  • preload_module_classes (List[str], opsional) — Daftar kelas yang instansnya harus memuat semua bobotnya (bahkan di submodul) di awal forward. Ini hanya harus digunakan untuk kelas yang memiliki submodul yang terdaftar tetapi tidak dipanggil secara langsung selama forward, misalnya jika lapisan linear dense terdaftar, tetapi saat forward, dense.weight dan dense.bias digunakan dalam beberapa operasi alih-alih memanggil dense secara langsung.
  • tied_params_map (Optional[Dict[int, Dict[torch.device, torch.Tensor]]], opsional, defaultnya None) — Peta dari pointer data ke kamus perangkat ke bobot terikat yang sudah didispatch. Untuk perangkat eksekusi tertentu, parameter ini berguna untuk menggunakan ulang pointer pertama yang tersedia dari bobot bersama untuk semua lainnya, alih-alih menduplikasi memori.

Melampirkan AlignDevicesHook secara rekursif ke semua submodul dari model tertentu untuk memastikan mereka memiliki perangkat eksekusi yang tepat

attach_align_device_hook

accelerate.hooks.attach_align_device_hook

< >

( module: Moduleexecution_device: torch.device | None = Noneoffload: bool = Falseweights_map: collections.abc.Mapping | None = Noneoffload_buffers: bool = Falsemodule_name: str = ''skip_keys: str | list[str] | None = Nonepreload_module_classes: list[str] | None = Nonetied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None )

Parameter

  • module (torch.nn.Module) — Modul tempat kita ingin menempelkan hook.
  • execution_device (torch.device, opsional) — Perangkat tempat input dan bobot model harus ditempatkan sebelum forward pass.
  • offload (bool, opsional, default False) — Apakah bobot harus di-offload setelah forward pass.
  • weights_map (Mapping[str, torch.Tensor], opsional) — Ketika bobot model di-offload, sebuah peta (yang mungkin lazy) dari nama parameter ke nilai tensor.
  • offload_buffers (bool, opsional, defaultnya False) — Apakah akan menyertakan buffer dari modul terkait saat melakukan offloading.
  • module_name (str, opsional, defaultnya "") — Nama modul.
  • skip_keys (str atau List[str], opsional) — Daftar kunci yang diabaikan saat memindahkan input atau output antar perangkat.
  • preload_module_classes (List[str], opsional) — Daftar kelas yang instansnya harus memuat semua bobotnya (bahkan di submodul) di awal forward. Ini hanya harus digunakan untuk kelas yang memiliki submodul yang terdaftar tetapi tidak dipanggil secara langsung selama forward, misalnya jika lapisan linear dense terdaftar, tetapi saat forward, dense.weight dan dense.bias digunakan dalam beberapa operasi alih-alih memanggil dense secara langsung.
  • tied_params_map (Optional[Dict[int, Dict[torch.device, torch.Tensor]]], opsional, defaultnya None) — Peta dari pointer data ke kamus perangkat ke bobot terikat yang sudah didispatch. Untuk perangkat eksekusi tertentu, parameter ini berguna untuk menggunakan ulang pointer pertama yang tersedia dari bobot bersama untuk semua lainnya, alih-alih menduplikasi memori.

Melampirkan AlignDevicesHook secara rekursif ke semua submodul dari model tertentu yang memiliki parameter dan/atau buffer langsung.

attach_align_device_hook_on_blocks

accelerate.hooks.attach_align_device_hook_on_blocks

< >

( module: Moduleexecution_device: torch.device | dict[str, torch.device] | None = Noneoffload: bool | dict[str, bool] = Falseweights_map: collections.abc.Mapping | None = Noneoffload_buffers: bool = Falsemodule_name: str = ''skip_keys: str | list[str] | None = Nonepreload_module_classes: list[str] | None = Nonetied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None )

Parameter

  • module (torch.nn.Module) — Modul tempat kita ingin menempelkan hook.
  • execution_device (torch.device atau Dict[str, torch.device], opsional) — Perangkat tempat input dan bobot model harus ditempatkan sebelum forward pass. Bisa berupa satu perangkat untuk seluruh modul, atau kamus yang memetakan nama modul ke perangkat.
  • offload (bool, opsional, default False) — Apakah bobot harus di-offload setelah forward pass. Nilainya bisa berupa satu boolean untuk seluruh modul, atau kamus yang memetakan nama modul ke boolean.
  • weights_map (Mapping[str, torch.Tensor], opsional) — Ketika bobot model di-offload, sebuah peta (yang mungkin lazy) dari nama parameter ke nilai tensor.
  • offload_buffers (bool, opsional, defaultnya False) — Apakah akan menyertakan buffer dari modul terkait saat melakukan offloading.
  • module_name (str, opsional, defaultnya "") — Nama modul.
  • skip_keys (str atau List[str], opsional) — Daftar kunci yang diabaikan saat memindahkan input atau output antar perangkat.
  • preload_module_classes (List[str], opsional) — Daftar kelas yang instansnya harus memuat semua bobotnya (bahkan di submodul) di awal forward. Ini hanya harus digunakan untuk kelas yang memiliki submodul yang terdaftar tetapi tidak dipanggil secara langsung selama forward, misalnya jika lapisan linear dense terdaftar, tetapi saat forward, dense.weight dan dense.bias digunakan dalam beberapa operasi alih-alih memanggil dense secara langsung.
  • tied_params_map (Optional[Dict[int, Dict[torch.device, torch.Tensor]]], opsional, defaultnya None) — Peta dari pointer data ke kamus perangkat ke bobot terikat yang sudah didispatch. Untuk perangkat eksekusi tertentu, parameter ini berguna untuk menggunakan ulang pointer pertama yang tersedia dari bobot bersama untuk semua lainnya, alih-alih menduplikasi memori.

Melampirkan AlignDevicesHook ke semua blok dari model tertentu sesuai kebutuhan.

attach_layerwise_casting_hooks

accelerate.big_modeling.attach_layerwise_casting_hooks

< >

( module: Modulestorage_dtype: dtypecompute_dtype: dtypeskip_modules_pattern: str | tuple[str, ...] | None = Noneskip_modules_classes: tuple[type[torch.nn.Module], ...] | None = Nonenon_blocking: bool = False )

Parameter

  • module (torch.nn.Module) — Modul yang modul daunnya akan di-cast ke dtype presisi tinggi untuk komputasi, dan ke dtype presisi rendah untuk penyimpanan.
  • storage_dtype (torch.dtype) — dtype untuk meng-cast modul sebelum/setelah forward pass untuk penyimpanan.
  • compute_dtype (torch.dtype) — dtype untuk meng-cast modul selama forward pass untuk komputasi.
  • skip_modules_pattern (tuple[str, ...], defaultnya None) — Daftar pola untuk mencocokkan nama modul yang akan dilewati selama proses casting layerwise. Jika diatur ke None bersamaan dengan skip_modules_classes yang bernilai None, casting layerwise diterapkan langsung ke modul tersebut, bukan ke submodul internalnya.
  • skip_modules_classes (tuple[type[torch.nn.Module], ...], defaultnya None) — Daftar kelas modul yang akan dilewati selama proses casting per lapisan.
  • non_blocking (bool, defaultnya False) — Jika True, operasi casting bobot bersifat non-blocking.

Menerapkan pencetakan (casting) per lapisan ke modul tertentu. Modul yang diharapkan di sini adalah nn.Module PyTorch. Hal ini berguna untuk mengurangi kebutuhan memori ketika Anda tidak ingin mengkuantisasi model secara penuh. Parameter model dapat disimpan dalam, misalnya, torch.float8_e4m3fn dan ditingkatkan presisinya (upcast) ke presisi yang lebih tinggi seperti torch.bfloat16 selama forward pass, lalu diturunkan kembali (downcast) ke torch.float8_e4m3fn untuk mewujudkan penghematan memori.

Contoh:

>>> from accelerate.hooks import attach_layerwise_casting_hooks
>>> from transformers import AutoModelForCausalLM
>>> import torch

>>> # Model
>>> checkpoint = "EleutherAI/gpt-j-6B"
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)

>>> # Attach hooks and perform inference
>>> attach_layerwise_casting_hooks(model, storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16)
>>> with torch.no_grad():
...     model(...)

Pengguna juga dapat meneruskan modul yang ingin dihindari dari proses downcast.

>>> attach_layerwise_casting_hooks(
...     model, storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16, skip_modules_pattern=["norm"]
... )

Menghapus Hook

remove_hook_from_module

accelerate.hooks.remove_hook_from_module

< >

( module: Modulerecurse = False ) → torch.nn.Module

Parameter

  • module (torch.nn.Module) — Modul tempat hook akan dilampirkan.
  • recurse (bool, opsional) — Apakah hook akan dihapus secara rekursif

Mengembalikan

torch.nn.Module

Modul yang sama, dengan hook dilepas (modul dimodifikasi di tempat, sehingga hasilnya dapat dibuang).

Menghapus hook apa pun yang terlampir pada modul melalui add_hook_to_module.

remove_hook_from_submodules

accelerate.hooks.remove_hook_from_submodules

< >

( module: Module )

Parameter

  • module (torch.nn.Module) — Modul tempat semua hook dihapus.

Menghapus secara rekursif semua hook yang terpasang pada submodul dari model tertentu.

Utilitas

has_offloaded_params

accelerate.utils.has_offloaded_params

< >

( module: Module ) → bool

Parameter

  • module (torch.nn.Module) — Modul yang akan diperiksa untuk hook offload.

Mengembalikan

bool

True jika modul memiliki offload hook dan offloading diaktifkan, False jika tidak.

Memeriksa apakah sebuah modul memiliki parameter yang di-offload dengan memeriksa apakah modul yang diberikan memiliki AlignDevicesHook yang terpasang dengan offloading diaktifkan

align_module_device

accelerate.utils.align_module_device

< >

( module: Moduleexecution_device: torch.device | None = None )

Parameter

  • module (torch.nn.Module) — Modul dengan parameter untuk diselaraskan.
  • execution_device (torch.device, opsional) — Jika diberikan, menimpa perangkat eksekusi modul di dalam konteks. Jika tidak, gunakan perangkat eksekusi hook atau pass

Context manager yang memindahkan parameter modul ke perangkat eksekusi yang ditentukan.

Update on GitHub

←Pencatatan Handler Kwargs→