vector listlengths 1.02k 1.02k | text stringlengths 2 11.8k |
|---|---|
[
0.015419194,
-0.0019309488,
-0.03887454,
-0.029872913,
-0.037369538,
-0.0076599033,
0.00753212,
-0.012884824,
0.018301418,
0.04219691,
-0.047507018,
-0.023398556,
0.04574645,
-0.06218791,
0.014510512,
0.07201303,
0.010229769,
-0.018415004,
-0.052022032,
0.004465319,
0.0539245... | If you're having difficulties installing DeepSpeed, check the DeepSpeed CUDA installation guide. While DeepSpeed has a pip installable PyPI package, it is highly recommended to install it from source to best match your hardware and to support certain features, like 1-bit Adam, which aren’t available in the PyPI distrib... |
[
0.03644411,
0.019168086,
-0.031728495,
-0.026809124,
-0.03213602,
-0.013528274,
-0.011003094,
0.016722955,
-0.012633181,
0.044827417,
-0.022733904,
0.0049521197,
0.046020873,
-0.05338538,
0.043342873,
0.06491243,
0.0032419828,
-0.014394258,
-0.07847709,
-0.00091556,
-0.001858... |
In GPU-limited environments, ZeRO also enables offloading optimizer memory and computation from the GPU to the CPU to fit and train really large models on a single GPU. DeepSpeed is integrated with the Transformers [Trainer] class for all ZeRO stages and offloading. All you need to do is provide a config file or you ... |
[
0.041756038,
-0.0076343957,
-0.025638208,
-0.018664949,
-0.014245768,
0.0061729345,
0.0016763309,
0.009235044,
0.010439009,
0.042173598,
-0.0043669855,
-0.029062202,
0.012763429,
-0.03298727,
0.030537583,
0.08234291,
-0.033905905,
-0.03437914,
-0.032235663,
-0.027489392,
0.02... | pip install deepspeed
pip install transformers[deepspeed]
Memory requirements
Before you begin, it is a good idea to check whether you have enough GPU and CPU memory to fit your model. DeepSpeed provides a tool for estimating the required CPU/GPU memory. For example, to estimate the memory requirements for the bigsci... |
[
0.04273111,
0.008831096,
0.0009516574,
0.045181025,
-0.032845978,
-0.043101445,
0.032845978,
0.00097569363,
-0.004454718,
0.053670272,
-0.0005866625,
-0.015838997,
0.055607416,
-0.043186907,
-0.009521916,
0.033472702,
0.0074565783,
-0.03623598,
-0.0902481,
0.0070328284,
-0.00... |
enable gradient checkpointing
try ZeRO-2
try ZeRO-2 and offload the optimizer
try ZeRO-3
try ZeRO-3 and offload parameters to the CPU
try ZeRO-3 and offload parameters and the optimizer to the CPU
try lowering various default values like a narrower search beam if you're using the [~GenerationMixin.generate] method
tr... |
[
0.0063433447,
-0.001001765,
0.0017346998,
-0.026508246,
-0.06456131,
0.00065105973,
-0.017695514,
0.03415809,
0.0344383,
0.08697843,
0.03421413,
0.021912735,
0.04079916,
-0.020245463,
0.0014036971,
0.041948035,
0.0013135031,
-0.016098294,
-0.07761928,
0.0011068453,
-0.0019807... | Find a complete list of DeepSpeed configuration options on the DeepSpeed Configuration JSON reference. You can also find more practical examples of various DeepSpeed configuration examples on the DeepSpeedExamples repository or the main DeepSpeed repository. To quickly find specific examples, you can:
```bash
git clone... |
[
0.017549407,
0.009758512,
-0.020110203,
-0.035388168,
-0.06394755,
0.008651728,
0.018721296,
0.018880442,
0.0059932745,
0.08263991,
-0.032986518,
0.03316013,
0.03044019,
-0.051563136,
0.0033709907,
0.050145295,
-0.015205628,
-0.0027362173,
-0.060012314,
0.021209752,
0.0008355... | The DeepSpeed configuration file is passed as a path to a JSON file if you're training from the command line interface or as a nested dict object if you're using the [Trainer] in a notebook setting.
py
TrainingArguments(, deepspeed="path/to/deepspeed_config.json")
py
ds_config_dict = dict(scheduler=scheduler_params, ... |
[
0.030507648,
0.019751024,
-0.002967588,
-0.031268932,
-0.066823594,
0.0018309524,
-0.0082542645,
0.031156149,
-0.016395746,
0.07945523,
-0.0074506896,
0.022175847,
0.03781031,
-0.04618441,
-0.0025446536,
0.056193847,
-0.026757633,
-0.0066576884,
-0.058082953,
0.011553151,
0.0... | py
ds_config_dict = dict(scheduler=scheduler_params, optimizer=optimizer_params)
args = TrainingArguments(, deepspeed=ds_config_dict)
trainer = Trainer(model, args, )
DeepSpeed and Trainer parameters
There are three types of configuration parameters: |
[
0.040009994,
0.011222672,
-0.02042877,
-0.00783249,
-0.022971407,
-0.018689841,
0.009016131,
0.022533022,
-0.0028202808,
0.04065296,
0.006780364,
-0.011756041,
0.03907477,
-0.063010626,
0.029912513,
0.07885096,
0.00015685985,
-0.03834413,
-0.062192306,
-0.010660077,
0.0171262... |
$ python -c 'from transformers import AutoModel; \
from deepspeed.runtime.zero.stage3 import estimate_zero3_model_states_mem_needs_all_live; \
model = AutoModel.from_pretrained("bigscience/T0_3B"); \
estimate_zero3_model_states_mem_needs_all_live(model, num_gpus_per_node=1, num_nodes=1)'
[]
Estimated memory needed fo... |
[
0.036494657,
-0.00040464243,
0.0075635104,
-0.017729674,
-0.05697078,
-0.0013615397,
-0.014278643,
0.030627904,
-0.0079876995,
0.054382503,
0.017873468,
0.057200845,
0.023912773,
-0.063844085,
0.001541281,
0.07598021,
-0.014825056,
0.0055144606,
-0.054986436,
-0.0042850305,
0... | DeepSpeed and Trainer parameters
There are three types of configuration parameters:
Some of the configuration parameters are shared by [Trainer] and DeepSpeed, and it can be difficult to identify errors when there are conflicting definitions. To make it easier, these shared configuration parameters are configured from... |
[
0.0189413,
0.0073892674,
0.0003720291,
-0.010622973,
-0.051335964,
0.01522506,
-0.001876125,
-0.0018293118,
-0.01039971,
0.04874324,
0.048800856,
0.028289516,
0.009153761,
-0.050586954,
0.032005757,
0.044306796,
-0.0062765563,
0.0072020153,
-0.08371623,
0.020511338,
0.0275261... | Some configuration parameters that are automatically derived from the model configuration so you don't need to manually adjust these values. The [Trainer] uses a configuration value auto to determine set the most correct or efficient value. You could set your own configuration parameters explicitly, but you must take c... |
[
0.00063089264,
0.0047490126,
-0.016007751,
-0.011735744,
-0.05314405,
0.021633612,
-0.0020904073,
0.019922003,
-0.008263422,
0.052582864,
0.029658532,
0.03134208,
0.03602796,
-0.06840823,
0.00008905495,
0.05409806,
-0.017593093,
-0.019571263,
-0.07323441,
-0.006804346,
0.0150... | Some configuration parameters specific to DeepSpeed only which need to be manually set based on your training needs.
You could also modify the DeepSpeed configuration and edit [TrainingArguments] from it:
Create or load a DeepSpeed configuration to used as the main configuration
Create a [TrainingArguments] object ba... |
[
0.009992282,
0.023513913,
0.0029769458,
-0.00689656,
-0.05652992,
0.020090142,
-0.020225888,
0.020482292,
0.0030391621,
0.074267164,
-0.004362668,
0.055081982,
0.03734474,
-0.044433605,
0.01665129,
0.038068708,
0.028883351,
-0.009321102,
-0.07903329,
0.022216802,
-0.002409459... | DeepSpeed configuration file
DeepSpeed works with the [Trainer] class by way of a config file containing all the parameters for configuring how you want setup your training run. When you execute your training script, DeepSpeed logs the configuration it received from [Trainer] to the console so you can see exactly what ... |
[
0.04313607,
0.011948077,
-0.02367652,
-0.019942746,
-0.042374674,
-0.018961715,
-0.011435598,
0.03839198,
-0.020762712,
0.06864287,
0.019547405,
0.008023953,
0.02386687,
-0.034584995,
0.0058166343,
0.04281394,
-0.0038472514,
0.011677195,
-0.079009585,
0.03115871,
-0.002959565... | Some values, such as scheduler.params.total_num_steps are calculated by the [Trainer] during training.
ZeRO configuration
There are three configurations, each corresponding to a different ZeRO stage. Stage 1 is not as interesting for scalability, and this guide focuses on stages 2 and 3. The zero_optimization configura... |
[
0.007974706,
-0.0061783683,
0.023887232,
0.0044299825,
-0.063148454,
0.026793832,
0.0007294163,
0.016864179,
0.0037844812,
0.049072843,
0.0059828735,
0.0299365,
0.034731653,
-0.019460939,
0.0005164009,
0.03753497,
0.026911866,
-0.010940323,
-0.06444684,
0.020228162,
0.0357054... | DeepSpeed doesn’t validate parameter names and any typos fallback on the parameter's default setting. You can watch the DeepSpeed engine startup log messages to see what values it is going to use.
The following configurations must be setup with DeepSpeed because the [Trainer] doesn't provide equivalent command line ar... |
[
0.023315722,
0.019944087,
-0.011643575,
-0.0029948275,
-0.05500339,
-0.029887557,
0.004064536,
0.012365048,
-0.023658602,
0.059603672,
0.0047717225,
0.026358766,
0.049231604,
-0.067146994,
0.02244424,
0.05366045,
-0.0026948089,
-0.018343987,
-0.07829054,
0.023330009,
0.012829... | The following configurations must be setup with DeepSpeed because the [Trainer] doesn't provide equivalent command line arguments.
ZeRO-1 shards the optimizer states across GPUs, and you can expect a tiny speed up. The ZeRO-1 config can be setup like this:
yml
{
"zero_optimization": {
"stage": 1
}
} |
[
0.0357084,
0.01859932,
-0.028486477,
-0.001004836,
-0.04808884,
-0.04502239,
0.029217267,
0.025162099,
-0.029804764,
0.05995343,
-0.007709117,
0.015819453,
0.05376321,
-0.039061435,
0.0002485223,
0.028744403,
-0.011004836,
-0.0015762135,
-0.06494,
0.036281567,
-0.0021243058,
... | ZeRO-1 shards the optimizer states across GPUs, and you can expect a tiny speed up. The ZeRO-1 config can be setup like this:
yml
{
"zero_optimization": {
"stage": 1
}
}
ZeRO-2 shards the optimizer and gradients across GPUs. This stage is primarily used for training since it's features are not relevant... |
[
0.0114902705,
-0.004943167,
-0.004369345,
0.0064641414,
-0.01883243,
-0.034456987,
0.057133332,
-0.007017223,
0.04134285,
0.047288477,
0.02906444,
0.008254743,
0.06050713,
-0.029092094,
-0.022966715,
0.016647756,
-0.024404727,
-0.0027705934,
-0.060894288,
0.03191281,
0.010681... | yml
{
"zero_optimization": {
"stage": 2,
"offload_optimizer": {
"device": "cpu",
"pin_memory": true
},
"allgather_partitions": true,
"allgather_bucket_size": 5e8,
"overlap_comm": true,
"reduce_scatter": true,
"reduce_bucket_size... |
[
0.06570564,
0.015068855,
-0.016358532,
-0.022996973,
-0.058592055,
-0.02501973,
-0.008430414,
0.026350133,
-0.020689132,
0.054302182,
0.012978221,
0.005647427,
0.030463524,
-0.046156853,
0.0039606653,
0.03632816,
0.0017868811,
-0.0067572277,
-0.04249146,
0.015136733,
0.007161... | ZeRO-3 shards the optimizer, gradient, and parameters across GPUs. Unlike ZeRO-2, ZeRO-3 can also be used for inference, in addition to training, because it allows large models to be loaded on multiple GPUs. Some important parameters to configure include: |
[
0.05153416,
-0.003323698,
-0.004516684,
0.036643993,
-0.038430814,
-0.029099641,
0.0370127,
0.004179883,
-0.00039684953,
0.049180094,
0.023895172,
0.01097618,
-0.0010316758,
-0.066481054,
0.015684308,
0.037041064,
0.01772639,
-0.036388732,
-0.044727225,
0.0054278206,
0.025100... |
device: "cpu" can help if you're running out of GPU memory and if you have free CPU memory available. This allows offloading model parameters to the CPU.
pin_memory: true can improve throughput, but less memory becomes available for other processes because the pinned memory is reserved for the specific process that r... |
[
0.025801271,
0.01256509,
-0.020860907,
0.028457075,
-0.016762974,
-0.03195531,
0.005093859,
-0.02859986,
0.029784976,
0.04143624,
0.017691076,
-0.01180119,
0.020860907,
-0.06825129,
-0.012722154,
0.019304547,
-0.017434062,
-0.0312985,
-0.08589953,
-0.017334113,
0.02130354,
... |
offload_optimizer should be enabled to reduce GPU memory usage.
overlap_comm when set to true trades off increased GPU memory usage to lower allreduce latency. This feature uses 4.5x the allgather_bucket_size and reduce_bucket_size values. In this example, they're set to 5e8 which means it requires 9GB of GPU memory.... |
[
0.028811911,
0.005811262,
-0.010617773,
0.044697836,
-0.015627949,
-0.038397778,
-0.014283756,
0.010386951,
0.042987045,
0.04046159,
0.042634025,
-0.009327889,
0.007881863,
-0.054229394,
-0.01723012,
-0.000342413,
0.009538344,
-0.04581121,
-0.03861502,
0.0059877723,
0.0043957... | Run into an OOM error during the optimizer step. In this case, reduce sub_group_size to reduce memory usage of the temporary buffers.
The optimizer step is taking a really long time. In this case, increase sub_group_size to improve bandwidth utilization as a result of increased data buffers. |
[
0.04615876,
0.00013701156,
-0.01688214,
0.031399354,
-0.019617474,
-0.021882672,
0.019418022,
-0.0071517588,
0.009830107,
0.0546212,
0.043594386,
0.022637738,
0.0040638233,
-0.03741139,
-0.017765425,
0.030943466,
0.006414501,
-0.03553085,
-0.037382897,
0.011967086,
-0.0061545... | sub_group_size controls which parameters are updated during the optimizer step. Parameters are grouped into buckets of sub_group_size and each bucket is updated one at a time. When used with NVMe offload, sub_group_size determines when model states are moved in and out of CPU memory from during the optimization step. T... |
[
0.02401782,
0.025861828,
-0.0216709,
-0.009341956,
-0.04803564,
0.0062673404,
0.0032632079,
0.016260795,
-0.029610801,
0.051296942,
0.0053339065,
0.00035408567,
0.05769763,
-0.054131534,
0.031637687,
0.04919386,
-0.013982455,
-0.004282365,
-0.07132195,
0.0061378027,
0.0102715... | from transformers import T5ForConditionalGeneration, T5Config
import deepspeed
with deepspeed.zero.Init():
config = T5Config.from_pretrained("google-t5/t5-small")
model = T5ForConditionalGeneration(config)
For pretrained models, the DeepSped config file needs to have is_deepspeed_zero3_enabled: true setup in [... |
[
0.027551109,
-0.01403688,
0.018621264,
-0.0019412705,
-0.05662537,
0.00033598914,
0.018083682,
0.017038383,
-0.029581977,
0.046291836,
0.02834255,
-0.02838735,
0.02325045,
-0.041154936,
-0.02744658,
0.03112006,
0.018890057,
-0.008855181,
-0.06176227,
0.017172778,
0.012663057,... | reduce_bucket_size, stage3_prefetch_bucket_size, and stage3_param_persistence_threshold are dependent on a model's hidden size. It is recommended to set these values to auto and allow the [Trainer] to automatically assign the values. |
[
0.04474688,
-0.018564885,
-0.00065889413,
0.008341165,
-0.04109762,
0.006824261,
0.0059807315,
0.026254399,
-0.017551202,
0.036666375,
0.02651506,
-0.0012137047,
0.030844934,
-0.06557083,
0.013489229,
0.06835122,
0.007885008,
-0.0088118045,
-0.039765347,
-0.026601946,
0.01211... |
You'll need ZeRO-3 if the fp16 weights don't fit on a single GPU. If you're able to load fp16 weights, then make sure you specify torch_dtype=torch.float16 in [~PreTrainedModel.from_pretrained].
Another consideration for ZeRO-3 is if you have multiple GPUs, no single GPU has all the parameters unless it's the paramet... |
[
0.078266025,
-0.027454346,
0.02130154,
-0.03353425,
-0.011649507,
0.002657225,
-0.014959193,
0.011576607,
0.0161256,
0.05983677,
0.025121529,
-0.0072426694,
0.016111022,
-0.048551764,
0.016417203,
0.053946406,
0.0062184166,
-0.022395048,
-0.056045942,
0.006754236,
0.000601429... | For more information about initializing large models with ZeRO-3 and accessing the parameters, take a look at the Constructing Massive Models and Gathering Parameters guides. |
[
0.034397673,
0.018462602,
-0.010160969,
-0.014257313,
-0.018738598,
-0.0032502024,
0.03477535,
-0.0048299097,
0.021164447,
0.03988852,
0.028500099,
-0.0110397935,
0.053020064,
-0.053194374,
0.018941963,
0.050347272,
-0.0056578945,
-0.020045942,
-0.07257212,
0.00896257,
0.0201... |
yml
{
"zero_optimization": {
"stage": 3,
"offload_optimizer": {
"device": "cpu",
"pin_memory": true
},
"offload_param": {
"device": "cpu",
"pin_memory": true
},
"overlap_comm": true,
"contiguous_gradients": tru... |
[
0.039652184,
0.02973914,
-0.00030040194,
-0.0007731478,
-0.074278034,
0.0024346302,
0.023176981,
0.005867546,
-0.012852055,
0.0573002,
0.017396698,
0.025033932,
0.004914637,
-0.07416634,
0.023204906,
0.060316,
-0.0048762416,
-0.006052543,
-0.06411368,
-0.011986408,
-0.0020384... | from transformers import AutoModel, Trainer, TrainingArguments
training_args = TrainingArguments(, deepspeed=ds_config)
model = AutoModel.from_pretrained("google-t5/t5-small")
trainer = Trainer(model=model, args=training_args, ) |
[
0.027515687,
0.007150458,
-0.0370682,
0.016737781,
-0.03946329,
0.0017963176,
0.0008041655,
0.014217367,
-0.014537641,
0.063442044,
0.03854424,
-0.014509791,
0.017670752,
-0.049349997,
-0.020943115,
0.011877976,
-0.025886469,
-0.038349293,
-0.050296895,
0.024173701,
0.0014830... | "scheduler": {
"type": "WarmupLR",
"params": {
"warmup_min_lr": "auto",
"warmup_max_lr": "auto",
"warmup_num_steps": "auto"
}
}, |
[
0.017383132,
0.03897951,
-0.011642234,
0.017411035,
-0.04927546,
-0.053516608,
0.026507184,
-0.01602987,
0.009179857,
0.060994424,
0.02148477,
0.0013087922,
0.04322066,
-0.04140701,
-0.020689555,
0.041323304,
-0.011042335,
-0.022098621,
-0.08471138,
0.027804641,
-0.0000492922... |
"zero_optimization": {
"stage": 3,
"offload_optimizer": {
"device": "nvme",
"nvme_path": "/local_nvme",
"pin_memory": true,
"buffer_count": 4,
"fast_init": false
},
"offload_param": {
"device": "nvme",
"nvme_path": "/local_nvme",
"pin_mem... |
[
0.048339248,
0.046884794,
0.00036495063,
0.007664409,
-0.06525086,
-0.026208714,
0.014337792,
0.004901657,
-0.0070726452,
0.0499363,
0.021232195,
0.016498085,
0.022743687,
-0.031170974,
0.02717835,
0.043434028,
0.013510749,
-0.020761635,
-0.09610812,
0.002021265,
-0.008997659... |
NVMe configuration
ZeRO-Infinity allows offloading model states to the CPU and/or NVMe to save even more memory. Smart partitioning and tiling algorithms allow each GPU to send and receive very small amounts of data during offloading such that a modern NVMe can fit an even larger total memory pool than is available t... |
[
0.020207204,
-0.00092059403,
0.0022654478,
0.015817182,
-0.023837162,
-0.03973297,
0.034019392,
0.008465534,
0.027493328,
0.05797449,
0.01659035,
0.0056677144,
0.04631145,
-0.051107712,
-0.009278015,
0.02801751,
0.008930746,
-0.044503022,
-0.05797449,
0.017848385,
0.004960069... | "gradient_accumulation_steps": "auto",
"gradient_clipping": "auto",
"steps_per_print": 2000,
"train_batch_size": "auto",
"train_micro_batch_size_per_gpu": "auto",
"wall_clock_breakdown": false
} |
[
0.02604163,
-0.011952441,
-0.026026793,
0.029335786,
-0.0019753801,
-0.009504083,
0.045999464,
-0.02026944,
-0.006762663,
0.023548758,
0.003935922,
-0.009400212,
0.041607257,
-0.07490493,
-0.019572029,
0.035018947,
-0.013599519,
-0.05045102,
-0.042200796,
-0.007241206,
0.0074... | For a Hugging Face model, set model.gradient_checkpointing_enable() or --gradient_checkpointing in the [Trainer].
For a non-Hugging Face model, use the DeepSpeed Activation Checkpointing API. You could also replace the Transformers modeling code and replace torch.utils.checkpoint with the DeepSpeed API. This approach i... |
[
0.038374715,
-0.012609032,
-0.026687616,
0.026687616,
0.00053635176,
0.0248992,
0.007174463,
0.016483936,
-0.0046374067,
0.063052095,
0.003110667,
0.01417563,
0.038485624,
-0.054955695,
-0.01702462,
0.047275208,
-0.020878728,
-0.03978881,
-0.051961135,
-0.0018421387,
0.019630... | }
DeepSpeed features
There are a number of important parameters to specify in the DeepSpeed configuration file which are briefly described in this section.
Activation/gradient checkpointing
Activation and gradient checkpointing trades speed for more GPU memory which allows you to overcome scenarios where your GPU is o... |
[
0.017942293,
0.000291338,
-0.024085734,
-0.0007674816,
-0.050410666,
-0.014870573,
-0.020310676,
0.0032816455,
-0.0047762385,
0.04001849,
0.02290872,
0.027200516,
0.036401324,
-0.06413294,
0.024846487,
0.036372617,
-0.003915008,
-0.013557197,
-0.06832425,
0.014454312,
0.01601... | The optimizer and scheduler parameters for the config file can be set from the command line to avoid hard to find errors. For example, if the learning rate is set to a different value in another place you can override it from the command line. Aside from the optimizer and scheduler parameters, you'll need to ensure you... |
[
-0.004288363,
0.010173047,
-0.041756403,
-0.01321866,
-0.035707187,
-0.028901815,
-0.015823184,
-0.010908195,
0.003542713,
0.043688793,
0.016481316,
0.01684539,
0.03310266,
-0.06306869,
0.018371698,
0.026115255,
-0.0068998886,
-0.021480322,
-0.104741074,
0.0020059037,
0.02954... | Optimizer and scheduler
DeepSpeed and Transformers optimizer and scheduler can be mixed and matched as long as you don't enable offload_optimizer. When offload_optimizer is enabled, you could use a non-DeepSpeed optimizer (except for LAMB) as long as it has both a CPU and GPU implementation. |
[
0.03675457,
0.003632553,
-0.009717794,
-0.008151792,
-0.051713824,
0.027244147,
-0.010382809,
-0.0050591165,
0.0050090617,
0.02376891,
0.0047409106,
0.008366313,
0.038356327,
-0.06618683,
0.013393251,
0.04650812,
0.0071506947,
-0.015774433,
-0.100395754,
0.011233741,
0.025413... |
DeepSpeed offers several optimizers (Adam, AdamW, OneBitAdam, and LAMB) but you can also import other optimizers from PyTorch. If you don't configure the optimizer in the config, the [Trainer] automatically selects AdamW and either uses the supplied values or the default values for the following parameters from the c... |
[
0.046776064,
0.020865247,
-0.0026342897,
0.03777209,
-0.05876278,
0.021464583,
-0.0016830184,
0.025785375,
-0.02582719,
0.068129145,
0.031081831,
-0.001973975,
0.024029182,
-0.03052431,
0.0024983939,
-0.009017913,
-0.018718788,
-0.028126966,
-0.052239776,
0.027541569,
0.00216... |
If you don't configure the scheduler in the config, the [Trainer] automatically selects WarmupDecayLR and either uses the supplied values or the default values for the following parameters from the command line: warmup_min_lr, warmup_max_lr, warmup_num_steps, total_num_steps (automatically calculated during run time ... |
[
-0.021149604,
-0.00001805355,
-0.0131335575,
0.009375169,
-0.045988254,
0.0441576,
-0.02454741,
-0.0076138573,
0.019943036,
0.042548843,
0.008681739,
0.016878078,
0.015435744,
-0.08071521,
0.021246685,
0.06523786,
-0.039359067,
-0.047957595,
-0.072227634,
-0.028846674,
0.0473... | Precision
Deepspeed supports fp32, fp16, and bf16 mixed precision. |
[
0.013779402,
-0.024669688,
-0.02142995,
0.031247336,
-0.038989045,
0.025258731,
0.02626852,
-0.0044493796,
0.003769175,
0.05845552,
0.034557197,
-0.023589775,
0.036688972,
-0.069002196,
-0.025090434,
0.046113662,
-0.019214027,
-0.028288096,
-0.056351792,
0.0012201607,
0.03189... |
If your model doesn't work well with mixed precision, for example if it wasn't pretrained in mixed precision, you may encounter overflow or underflow issues which can cause NaN loss. For these cases, you should use full fp32 precision by explicitly disabling the default fp16 mode.
yaml
{
"fp16": {
"enable... |
[
0.023294097,
0.014330965,
-0.026738694,
-0.02388255,
-0.01997867,
0.036972024,
-0.028934626,
-0.0073700054,
-0.03909619,
0.047133587,
0.020337483,
-0.012278558,
0.04541129,
-0.06762895,
0.019189283,
0.036512744,
-0.0056154127,
-0.0038787613,
-0.054855227,
0.0010199241,
0.0235... | DeepSpeed supports the LRRangeTest, OneCycle, WarmupLR and WarmupDecayLR learning rate schedulers.
Transformers and DeepSpeed provide two of the same schedulers:
WarmupLR is the same as --lr_scheduler_type constant_with_warmup in Transformers
WarmupDecayLR is the same as --lr_scheduler_type linear in Transformers (th... |
[
0.030839942,
0.014655796,
0.027087294,
0.0056699095,
-0.04620533,
0.0027172582,
0.038590867,
0.022092862,
-0.0207692,
0.05802276,
0.02958451,
0.013079683,
0.022857036,
-0.008501453,
-0.01954106,
0.049316615,
-0.043421548,
-0.035343118,
-0.0500535,
0.010773511,
0.006355621,
... |
Batch size
The batch size can be auto-configured or explicitly set. If you choose to use the "auto" option, [Trainer] sets train_micro_batch_size_per_gpu to the value of args.per_device_train_batch_size and train_batch_size to args.world_size * args.per_device_train_batch_size * args.gradient_accumulation_steps.
yaml... |
[
0.039463546,
0.04864497,
-0.024225693,
0.0024422735,
-0.036698055,
-0.004856892,
-0.0044731805,
0.013765227,
0.031111764,
0.07649346,
0.023188636,
-0.034623936,
0.03324119,
-0.03932527,
0.004780841,
0.06238946,
0.004735902,
-0.056416,
-0.05450781,
-0.017823584,
0.022276023,
... | To deploy DeepSpeed on multiple GPUs, add the --num_gpus parameter. If you want to use all available GPUs, you don't need to add --num_gpus. The example below uses 2 GPUs. |
[
0.005295235,
-0.015491845,
-0.046533886,
0.026184427,
-0.03903595,
0.036264338,
-0.025965616,
0.0043142308,
-0.00923384,
0.068794295,
0.024404762,
0.015345971,
0.047730055,
-0.07083654,
0.018613555,
0.07077818,
-0.053156577,
-0.027482709,
-0.049655594,
-0.019561736,
0.0045695... |
To configure PyTorch AMP-like fp16 mixed precision reduces memory usage and accelerates training speed. [Trainer] automatically enables or disables fp16 based on the value of args.fp16_backend, and the rest of the config can be set by you. fp16 is enabled from the command line when the following arguments are passed:... |
[
0.028652195,
0.013609792,
-0.018595558,
0.008028288,
-0.027602559,
-0.016014023,
0.0133261075,
0.02256715,
0.013389937,
0.05957387,
0.033872,
0.009609832,
0.044510193,
-0.029247934,
-0.0010886416,
0.053985275,
-0.00833325,
-0.01570197,
-0.06422631,
0.00055407244,
0.021474961,... | deepspeed --num_gpus=2 examples/pytorch/translation/run_translation.py \
--deepspeed tests/deepspeed/ds_config_zero3.json \
--model_name_or_path google-t5/t5-small --per_device_train_batch_size 1 \
--output_dir output_dir --overwrite_output_dir --fp16 \
--do_train --max_train_samples 500 --num_train_epochs 1 \
--datase... |
[
-0.0027801592,
-0.034460332,
-0.023433026,
0.015823036,
-0.047210656,
0.022126405,
-0.014028227,
0.010101185,
-0.007545377,
0.053901706,
-0.0031768118,
-0.00015267094,
0.045286622,
-0.065761805,
0.078052655,
0.03655667,
-0.022384858,
-0.051317178,
-0.07477892,
-0.025802175,
0... | To use bf16, you'll need at least DeepSpeed==0.6.0. bf16 has the same dynamic range as fp32 and doesn’t require loss scaling. However, if you use gradient accumulation with bf16, gradients are accumulated in bf16 which may not be desired because this format's low precision can lead to lossy accumulation.
bf16 can be se... |
[
0.029209154,
0.045386095,
-0.031815596,
0.011976887,
-0.023344658,
-0.0048764558,
-0.002586965,
0.00938461,
0.036405202,
0.06295125,
0.015751978,
-0.020171598,
0.047454253,
-0.040796492,
-0.0013005652,
0.04204305,
0.003291696,
-0.039379947,
-0.054480314,
-0.0020061815,
0.0357... | To deploy DeepSpeed on a single GPU, add the --num_gpus parameter. It isn't necessary to explicitly set this value if you only have 1 GPU because DeepSpeed deploys all GPUs it can see on a given node. |
[
-0.014872734,
-0.031453717,
-0.018618345,
0.04284727,
-0.06626125,
0.014096971,
0.006703701,
0.0073658433,
-0.009034912,
0.053222135,
0.0011822571,
0.020373609,
0.05435052,
-0.04262786,
0.016627999,
0.021031834,
-0.039085984,
-0.023084866,
-0.06738963,
-0.0040316237,
0.018900... |
Gradient clipping
Gradient clipping can be auto-configured or explicitly set. If you choose to use the "auto" option, [Trainer] sets it to the value of args.max_grad_norm.
yaml
{
"gradient_clipping": "auto"
}
Communication data type
For communication collectives like reduction, gathering and scattering operations... |
[
0.0464389,
0.025587603,
-0.0020667189,
0.021992054,
-0.026251841,
-0.0077542565,
0.035262372,
0.028273435,
0.011956284,
0.0531968,
0.0049059754,
-0.02014374,
0.018670864,
-0.017530108,
0.0017282823,
0.03638869,
-0.00023070087,
-0.06313149,
-0.064459965,
0.0041803676,
0.000334... | Offload some computations and memory to the CPU to make more GPU resources available to your model to use a larger batch size or fit a very large model that normally won't fit.
Minimize memory fragmentation with it's smart GPU memory management system which also allows you to fit bigger models and data batches.
Set th... |
[
0.04242576,
0.027667718,
-0.027653277,
0.0014187648,
-0.03748716,
-0.012360943,
0.02040422,
0.019263431,
0.016202077,
0.06677219,
0.041472696,
0.0019368124,
0.04040411,
-0.040201943,
0.007097434,
0.043118898,
-0.00047337284,
-0.023898786,
-0.060245156,
-0.0037689323,
0.022396... | deepspeed --num_gpus=1 examples/pytorch/translation/run_translation.py \
--deepspeed tests/deepspeed/ds_config_zero2.json \
--model_name_or_path google-t5/t5-small --per_device_train_batch_size 1 \
--output_dir output_dir --overwrite_output_dir --fp16 \
--do_train --max_train_samples 500 --num_train_epochs 1 \
--datase... |
[
0.023962772,
0.018091593,
-0.019525774,
0.032000158,
-0.010577084,
-0.023649044,
-0.039559487,
0.015596717,
0.009583615,
0.041591246,
-0.022946894,
-0.0073837903,
0.054947052,
-0.050793905,
0.01066672,
0.03197028,
-0.024874074,
-0.012743294,
-0.038902156,
-0.020227926,
0.0663... |
Multi-node deployment
A node is one or more GPUs for running a workload. A more powerful setup is a multi-node setup which can be launched with the deepspeed launcher. For this guide, let's assume there are two nodes with 8 GPUs each. The first node can be accessed ssh hostname1 and the second node with ssh hostname2... |
[
0.017924534,
0.041761424,
-0.006543248,
0.019727081,
-0.026057629,
-0.021342164,
-0.022510216,
0.026706547,
0.008053783,
0.043722596,
-0.0036519617,
0.026432559,
0.06598766,
-0.048048712,
0.018241782,
0.039829094,
-0.008046573,
-0.029287795,
-0.058748633,
-0.012358267,
0.0146... | For the deepspeed launcher, start by creating a hostfile.
hostname1 slots=8
hostname2 slots=8
Then you can launch the training with the following command. The deepspeed launcher automatically launches the command on both nodes at once. |
[
0.0193732,
0.0038356585,
-0.042394508,
0.0032601259,
0.013091989,
0.017460888,
-0.029008318,
0.009039356,
0.015945747,
0.046307396,
-0.024242245,
0.0097233765,
0.07249137,
-0.06790182,
0.00591346,
0.039187707,
-0.01784335,
-0.01613698,
-0.030302806,
-0.011385618,
0.04830797,
... | For torchrun, you have to ssh to each node and run the following command on both of them. The launcher waits until both nodes are synchronized before launching the training.
python -m torch.run --nproc_per_node=8 --nnode=2 --node_rank=0 --master_addr=hostname1 \
--master_port=9901 your_program.py <normal cl args> --de... |
[
0.024229474,
0.015740525,
-0.016920345,
0.01481969,
-0.0144671835,
-0.037207495,
-0.027150247,
0.008683188,
0.010625574,
0.037466478,
-0.0022193566,
0.012891692,
0.0222727,
-0.03723627,
-0.02271873,
0.053494766,
-0.011165126,
-0.004708489,
-0.07286108,
-0.049235903,
0.0326608... |
SLURM
In a SLURM environment, you'll need to adapt your SLURM script to your specific SLURM environment. An example SLURM script may look like:
```bash
SBATCH --job-name=test-nodes # name
SBATCH --nodes=2 # nodes
SBATCH --ntasks-per-node=1 # crucial - only 1 task per dist per node!
... |
[
0.009503367,
0.051023584,
-0.03373658,
0.04471293,
-0.013690531,
-0.010415571,
-0.030042902,
0.0110586,
0.031194372,
0.06382434,
-0.047673855,
0.0041759484,
0.057573505,
-0.040077142,
0.00075798883,
0.044354033,
-0.02582583,
-0.016629023,
-0.05772305,
-0.01694306,
0.03834246,... | Then you can schedule your multi-node deployment with the following command which launches training simultaneously on all nodes.
sbatch launch.slurm
Notebook
The deepspeed launcher doesn't support deployment from a notebook so you'll need to emulate the distributed environment. However, this only works for 1 GPU. If y... |
[
-0.005043478,
0.00424263,
0.0027713056,
-0.03319607,
-0.014422708,
0.008976944,
0.026565794,
-0.012344229,
0.046009634,
0.04317873,
0.052922998,
-0.00032802165,
0.0411226,
-0.027653458,
-0.0009382024,
-0.0012320018,
-0.021961851,
0.014951641,
-0.044162095,
0.025582429,
-0.018... | If you want to create the config file on the fly in the notebook in the current directory, you could have a dedicated cell. |
[
0.018352484,
0.036536984,
-0.026079847,
0.013592877,
-0.028389657,
-0.02557589,
-0.014187829,
0.027661717,
0.0026947774,
0.041716557,
-0.0048995954,
0.016924603,
0.05462349,
-0.052299682,
0.017834527,
0.0387768,
-0.013179912,
-0.026835784,
-0.05767524,
-0.0118640205,
0.022972... | hostname1 slots=8
hostname2 slots=8
Then you can launch the training with the following command. The deepspeed launcher automatically launches the command on both nodes at once.
deepspeed --num_gpus 8 --num_nodes 2 --hostfile hostfile --master_addr hostname1 --master_port=9901 \
your_program.py <normal cl args> --deep... |
[
0.025146702,
0.0107331695,
0.014787434,
-0.019384222,
-0.07143716,
-0.015997116,
0.0015689196,
0.033548485,
-0.0001155841,
0.08410582,
0.017712662,
-0.00811586,
0.036217116,
-0.034604207,
0.006352658,
0.021906223,
0.0012655829,
-0.0037646738,
-0.071965024,
0.014912068,
0.0160... | %%bash
cat <<'EOT' > ds_config_zero3.json
{
"fp16": {
"enabled": "auto",
"loss_scale": 0,
"loss_scale_window": 1000,
"initial_scale_power": 16,
"hysteresis": 2,
"min_loss_scale": 1
},
"optimizer": {
"type": "AdamW",
"params": {
"lr": "auto",
... |
[
0.01380612,
0.029314669,
-0.02090705,
-0.008318019,
-0.04521896,
-0.01039379,
-0.0056299698,
0.025028724,
-0.0002816385,
0.06582734,
-0.0120364865,
0.020936916,
0.06313929,
-0.022997754,
-0.005984643,
0.024282044,
-0.04187383,
-0.026268214,
-0.06552867,
-0.0041142087,
0.00460... | DeepSpeed requires a distributed environment even when only one process is used.
This emulates a launcher in the notebook
import os
os.environ["MASTER_ADDR"] = "localhost"
os.environ["MASTER_PORT"] = "9994" # modify if RuntimeError: Address already in use
os.environ["RANK"] = "0"
os.environ["LOCAL_RANK"] = "0"
os.envi... |
[
0.018456856,
0.011403061,
-0.0062864795,
0.008560898,
-0.036060374,
-0.052466467,
0.025366133,
0.0023759245,
0.022228055,
0.041730937,
0.021003103,
-0.0017195775,
0.052741736,
-0.05508153,
-0.014933399,
0.022021603,
-0.015483939,
-0.004328621,
-0.0721758,
0.01603448,
0.005935... |
"zero_optimization": {
"stage": 3,
"offload_optimizer": {
"device": "cpu",
"pin_memory": true
},
"offload_param": {
"device": "cpu",
"pin_memory": true
},
"overlap_comm": true,
"contiguous_gradients": true,
"sub_group_size": 1e9,
"reduce_bucket_size"... |
[
0.020431982,
-0.00050628284,
-0.0041488092,
0.017304773,
-0.029353729,
-0.038078383,
0.03411024,
0.006852269,
0.029064659,
0.053372804,
0.011208026,
0.012745352,
0.048957918,
-0.05602699,
-0.0032339687,
0.031771403,
0.005058722,
-0.036606755,
-0.053057455,
0.020392563,
-0.000... | "gradient_accumulation_steps": "auto",
"gradient_clipping": "auto",
"steps_per_print": 2000,
"train_batch_size": "auto",
"train_micro_batch_size_per_gpu": "auto",
"wall_clock_breakdown": false
}
EOT |
[
0.019859806,
0.017815413,
-0.032095414,
0.004319354,
-0.016278276,
0.0060524754,
0.0058372766,
-0.0059602475,
0.009099849,
0.06040947,
-0.015125425,
0.04362394,
0.04543776,
-0.029051883,
-0.01091367,
0.015771022,
0.018952895,
-0.037198707,
-0.048204605,
0.0012518057,
0.001211... |
If the training script is in a file and not in a notebook cell, you can launch deepspeed normally from the shell in a notebook cell. For example, to launch run_translation.py:
py
!git clone https://github.com/huggingface/transformers
!cd transformers; deepspeed examples/pytorch/translation/run_translation.py
You cou... |
[
0.027515687,
0.007150458,
-0.0370682,
0.016737781,
-0.03946329,
0.0017963176,
0.0008041655,
0.014217367,
-0.014537641,
0.063442044,
0.03854424,
-0.014509791,
0.017670752,
-0.049349997,
-0.020943115,
0.011877976,
-0.025886469,
-0.038349293,
-0.050296895,
0.024173701,
0.0014830... | "scheduler": {
"type": "WarmupLR",
"params": {
"warmup_min_lr": "auto",
"warmup_max_lr": "auto",
"warmup_num_steps": "auto"
}
}, |
[
0.007772243,
-0.028510366,
-0.009032411,
0.021969153,
-0.021036774,
-0.03510985,
-0.035080716,
-0.020847386,
0.009163526,
0.027432304,
0.0007443544,
0.0074590226,
0.05011531,
-0.053058125,
-0.0037295113,
0.0567585,
0.01081704,
-0.009374768,
-0.06672329,
-0.000929191,
0.019011... | from transformers.trainer_utils import get_last_checkpoint
from deepspeed.utils.zero_to_fp32 import load_state_dict_from_zero_checkpoint
checkpoint_dir = get_last_checkpoint(trainer.args.output_dir)
fp32_model = load_state_dict_from_zero_checkpoint(trainer.model, checkpoint_dir)
If you've enabled the --load_best_model... |
[
-0.005460654,
-0.03129247,
0.01094349,
0.021842616,
-0.025465798,
-0.018086337,
-0.041585263,
-0.009597736,
-0.0097899875,
0.067790486,
-0.015394829,
-0.011327991,
0.044897888,
-0.05453999,
-0.0026693244,
0.056432918,
0.0056566014,
-0.020970093,
-0.07423827,
0.0017163904,
0.0... | from deepspeed.utils.zero_to_fp32 import load_state_dict_from_zero_checkpoint
checkpoint_dir = os.path.join(trainer.args.output_dir, "checkpoint-final")
trainer.deepspeed.save_checkpoint(checkpoint_dir)
fp32_model = load_state_dict_from_zero_checkpoint(trainer.model, checkpoint_dir) |
[
0.014373235,
-0.0068169124,
-0.0049042534,
0.0139582595,
-0.0075978204,
0.017670402,
0.007586503,
-0.011204333,
-0.0046062255,
0.009137001,
-0.0033763899,
0.0053041386,
0.034978643,
-0.069172606,
-0.014018619,
0.058006,
-0.0072318874,
-0.013437654,
-0.067784324,
-0.013392384,
... | %%bash
git clone https://github.com/huggingface/transformers
cd transformers
deepspeed examples/pytorch/translation/run_translation.py
Save model weights
DeepSpeed stores the main full precision fp32 weights in custom checkpoint optimizer files (the glob pattern looks like global_step*/*optim_states.pt) and are saved... |
[
-0.0053096646,
-0.031467892,
0.011226148,
0.010091975,
-0.029112855,
-0.0044355565,
-0.02593428,
-0.0040382347,
-0.0008059313,
0.056318566,
-0.0029040615,
-0.013501719,
0.05218642,
-0.060913052,
-0.0073974105,
0.06825267,
0.0041429834,
-0.020574048,
-0.073165014,
0.016586382,
... | Once load_state_dict_from_zero_checkpoint is run, the model is no longer usable in DeepSpeed in the context of the same application. You'll need to initialize the DeepSpeed engine again since model.load_state_dict(state_dict) removes all the DeepSpeed magic from it. Only use this at the very end of training.
You can a... |
[
0.027312659,
-0.013547543,
0.0011286597,
0.042876378,
-0.03104041,
-0.007535277,
0.017144749,
-0.012691757,
0.020074733,
0.03211377,
0.025891183,
0.004764848,
0.008434579,
-0.03736453,
-0.005388557,
0.027805826,
0.0023479748,
-0.027428698,
-0.08209753,
-0.009769026,
0.0050767... | The full precision weights shouldn't be saved during training because it can require a lot of memory. It is usually best to save the fp32 weights offline after training is complete. But if you have a lot of free CPU memory, it is possible to save the fp32 weights during training. This section covers both online and off... |
[
-0.004037366,
-0.034883976,
-0.015155213,
0.013578616,
-0.008536347,
0.0062105125,
-0.025623247,
-0.010049028,
-0.0019263596,
0.052808885,
0.016518755,
-0.025751079,
0.026716921,
-0.075335756,
0.0044457186,
0.07527894,
-0.0055109863,
-0.043548156,
-0.064256966,
-0.010879938,
... | You can also extract and load the state_dict of the fp32 weights:
from deepspeed.utils.zero_to_fp32 import get_fp32_state_dict_from_zero_checkpoint
state_dict = get_fp32_state_dict_from_zero_checkpoint(checkpoint_dir) # already on cpu
model = model.cpu()
model.load_state_dict(state_dict) |
[
0.045797408,
-0.0064707305,
0.0032279785,
0.00036864143,
-0.030063782,
0.0042584203,
-0.015955226,
0.023740785,
-0.008671961,
0.03885393,
-0.004343367,
0.005562169,
0.052031763,
-0.070734836,
0.031319518,
0.051736295,
0.026680684,
-0.005244542,
-0.06902113,
-0.0062195836,
0.0... |
A model trained with ZeRO-2 saves the pytorch_model.bin weights in fp16. To save the model weights in fp16 for a model trained with ZeRO-3, you need to set "stage3_gather_16bit_weights_on_model_save": true because the model weights are partitioned across multiple GPUs. Otherwise, the [Trainer] won't save the weights ... |
[
0.016440682,
-0.008995845,
-0.004926296,
0.0312565,
-0.04638252,
-0.012467149,
-0.016558854,
0.016765656,
-0.009328204,
0.057195257,
0.011817202,
0.015938452,
0.017371288,
-0.07243945,
-0.0024059084,
0.06493553,
0.02054716,
-0.004398215,
-0.056249883,
-0.015052161,
0.00994860... | Offline
DeepSpeed provides a zero_to_fp32.py script at the top-level of the checkpoint folder for extracting weights at any point. This is a standalone script and you don't need a configuration file or [Trainer].
For example, if your checkpoint folder looked like this: |
[
0.04471307,
0.00015226807,
-0.0038128302,
0.027123515,
-0.024709854,
-0.023880158,
-0.07452178,
-0.0044087027,
-0.015077839,
0.055091813,
0.00919454,
0.007414465,
0.017453786,
-0.06341894,
-0.013471246,
0.07331495,
0.00035002799,
0.020923425,
-0.024393061,
0.0035262078,
0.030... |
$ ls -l output_dir/checkpoint-1/
-rw-rw-r-- 1 stas stas 1.4K Mar 27 20:42 config.json
drwxrwxr-x 2 stas stas 4.0K Mar 25 19:52 global_step1/
-rw-rw-r-- 1 stas stas 12 Mar 27 13:16 latest
-rw-rw-r-- 1 stas stas 827K Mar 27 20:42 optimizer.pt
-rw-rw-r-- 1 stas stas 231M Mar 27 20:42 pytorch_model.bin
-rw-rw-r-- 1 sta... |
[
0.014973036,
-0.014451868,
0.0016700288,
0.016029458,
-0.034763362,
-0.019860754,
-0.018381761,
0.013810971,
-0.009944462,
0.05887798,
0.025664037,
0.000032105356,
0.0034016822,
-0.061638765,
-0.0001318328,
0.05825821,
0.019395927,
-0.054877657,
-0.03932711,
-0.0032520224,
0.... | Run python zero_to_fp32.py -h for more usage details. The script requires 2x the general RAM of the final fp32 weights. |
[
0.047680743,
0.012107305,
-0.026557066,
-0.03515069,
-0.03728523,
-0.0017005323,
-0.007366952,
0.036952578,
-0.04884504,
0.06885986,
0.0175199,
-0.004660654,
0.015953643,
-0.029162873,
0.013763656,
0.03761789,
-0.00073331664,
-0.02623827,
-0.035095245,
0.026155105,
-0.0011504... |
ZeRO Inference
ZeRO Inference places the model weights in CPU or NVMe memory to avoid burdening the GPU which makes it possible to run inference with huge models on a GPU. Inference doesn't require any large additional amounts of memory for the optimizer states and gradients so you can fit much larger batches and/or ... |
[
0.0072622234,
0.029911878,
-0.031535454,
-0.013954001,
-0.07430432,
-0.005444839,
0.0019801077,
0.017245037,
-0.020901747,
0.06915568,
0.030394563,
0.02218891,
0.038176037,
-0.04976049,
0.016528323,
0.051047653,
0.015840862,
-0.031184413,
-0.07828282,
0.004640363,
0.006633269... | deepspeed --num_gpus=2 your_program.py <normal cl args> --do_eval --deepspeed ds_config.json
Non-Trainer DeepSpeed integration
DeepSpeed also works with Transformers without the [Trainer] class. This is handled by the [HfDeepSpeedConfig] which only takes care of gathering ZeRO-3 parameters and splitting a model across ... |
[
0.034750797,
0.009691805,
-0.00930617,
-0.0073779956,
-0.07526429,
0.02073697,
-0.012158413,
0.03818513,
-0.0026703398,
0.045810513,
0.017782861,
0.002739463,
0.027460115,
-0.042783644,
0.0054716496,
0.04732395,
0.0031232787,
-0.021901151,
-0.05608441,
0.017302638,
0.02782392... | If you want everything automatically taken care of for you, try using DeepSpeed with the [Trainer]! You'll need to follow the DeepSpeed documentation, and manually configure the parameter values in the config file (you can't use the "auto" value).
To efficiently deploy ZeRO-3, you must instantiate the [HfDeepSpeedConf... |
[
0.00016813284,
0.026987609,
-0.0023315672,
-0.041600265,
-0.06728129,
0.032048725,
-0.023908889,
-0.0034335237,
-0.01701556,
0.083560966,
-0.016084434,
0.0068970835,
0.061994907,
-0.04205081,
0.020725042,
0.07641233,
-0.006544157,
-0.01611447,
-0.0707655,
0.003303992,
0.03832... | from transformers.integrations import HfDeepSpeedConfig
from transformers import AutoModel
import deepspeed
ds_config = {} # deepspeed config object or path to the file
must run before instantiating the model to detect zero 3
dschf = HfDeepSpeedConfig(ds_config) # keep this object alive
model = AutoModel.from_pretrai... |
[
-0.014523337,
0.024831885,
-0.010190652,
-0.04129314,
-0.06015653,
0.033040408,
-0.024492934,
0.0023929242,
-0.004962693,
0.077929385,
-0.017404426,
0.008849583,
0.062956564,
-0.049929038,
0.021118155,
0.075571455,
-0.014081227,
-0.020543411,
-0.080582045,
0.006738504,
0.0392... | from transformers.integrations import HfDeepSpeedConfig
from transformers import AutoModel, AutoConfig
import deepspeed
ds_config = {} # deepspeed config object or path to the file
must run before instantiating the model to detect zero 3
dschf = HfDeepSpeedConfig(ds_config) # keep this object alive
config = AutoConfi... |
[
0.03960786,
0.013115408,
-0.031986836,
-0.03391893,
-0.044438086,
-0.051656593,
0.005132116,
0.039688364,
-0.030188918,
0.080503784,
0.02541236,
0.022031201,
0.006621436,
-0.03504598,
0.00424322,
0.02620398,
0.011545584,
-0.03534116,
-0.054715738,
0.010747255,
-0.0075271036,
... | Non-Trainer ZeRO Inference
To run ZeRO Inference without the [Trainer] in cases where you can’t fit a model onto a single GPU, try using additional GPUs or/and offloading to CPU memory. The important nuance to understand here is that the way ZeRO is designed, you can process different inputs on different GPUs in parall... |
[
0.040083364,
0.015339164,
-0.045373693,
-0.021749143,
-0.06286818,
-0.016276868,
-0.00018806571,
0.0415389,
-0.009041149,
0.08363763,
0.0073056966,
-0.004100707,
0.023960445,
-0.04453396,
0.0013409522,
0.059621204,
0.008782231,
-0.057213962,
-0.066507034,
0.014597397,
0.01243... | Take a look at the following script to get a better idea of how to run ZeRO Inference without the [Trainer] on a model that won't fit on a single GPU.
!/usr/bin/env python
This script demonstrates how to use Deepspeed ZeRO in an inference mode when one can't fit a model
into a single GPU
1. Use 1 GPU with CPU offload... |
[
0.02681042,
-0.014538145,
-0.019463943,
0.013954085,
-0.045176614,
-0.010562321,
0.028288161,
0.032116212,
-0.023686057,
0.06637163,
0.009281613,
0.018281752,
0.034677625,
-0.046949904,
0.011814881,
0.048216537,
-0.0062416913,
-0.05215718,
-0.07566027,
-0.012877447,
0.0114982... | disable CPU offload if you have enough GPU memory (since it slows things down).
enable bf16 if you have an Ampere or newer GPU to make things faster. If you don’t have one of these GPUs, you may enable fp16 as long as you don’t use a model pretrained in bf16 (T5 models) because it may lead to an overflow error.
Take a... |
[
0.025945785,
0.0016046826,
-0.04416486,
0.010820247,
-0.00092841714,
0.008909954,
-0.009216456,
0.012231585,
0.01749202,
0.0726482,
0.0033447966,
-0.022994809,
0.0500383,
-0.07036725,
0.007555641,
0.055541087,
-0.010606409,
-0.037008382,
-0.056396443,
-0.013635793,
0.02741414... | The provided deepspeed config also activates CPU memory offloading, so chances are that if you
have a lot of available CPU memory and you don't mind a slowdown you should be able to load a
model that doesn't normally fit into a single GPU. If you have enough GPU memory the program will
run faster if you don't want offl... |
[
0.025952399,
-0.026023077,
-0.030956294,
0.049954128,
-0.039409198,
0.02015693,
0.042632047,
0.0032104787,
0.002622097,
0.050745703,
0.007463435,
0.016919946,
0.040737916,
-0.05490148,
0.0341226,
0.03593192,
-0.010672146,
-0.03417914,
-0.06643588,
-0.022828499,
0.02480744,
... | - enable bf16 if you use Ampere or higher GPU - this will run in mixed precision and will be
faster.
- for older GPUs you can enable fp16, but it'll only work for non-bf16 pretrained models - e.g.
all official t5 models are bf16-pretrained
- set offload_param.device to "none" or completely remove the offload_param se... |
[
0.0027308525,
-0.010142072,
-0.0078057186,
-0.0082653295,
-0.043325953,
-0.028296689,
0.020100301,
0.0048259106,
-0.0057796026,
0.059963852,
0.008916444,
0.012800153,
0.056961063,
-0.07500844,
0.014447091,
0.04133431,
-0.020912278,
-0.0027270224,
-0.06630648,
0.006760105,
0.0... |
For in-depth info on Deepspeed config see
https://huggingface.co/docs/transformers/main/main_classes/deepspeed
keeping the same format as json for consistency, except it uses lower case for true/false
fmt: off
ds_config = {
"fp16": {
"enabled": False
},
"bf16": {
"enabled": False
},
... |
[
0.04095889,
0.022045022,
0.0051128087,
-0.007912512,
-0.049449675,
-0.0064527174,
0.0023289726,
0.012157907,
0.020719217,
0.06815198,
-0.002068043,
0.0040267776,
0.016473822,
-0.056642868,
-0.009971741,
0.048659835,
-0.0056981375,
-0.0797175,
-0.05918164,
-0.02279255,
0.00987... | 1. Use 1 GPU with CPU offload
2. Or use multiple GPUs instead
First you need to install deepspeed: pip install deepspeed
Here we use a 3B "bigscience/T0_3B" model which needs about 15GB GPU RAM - so 1 largish or 2
small GPUs can handle it. or 1 small GPU and a lot of CPU memory.
To use a larger model like "bigscienc... |
[
-0.0047569973,
-0.013031048,
0.010291868,
0.010478026,
-0.0012440993,
0.011787779,
-0.017219597,
-0.009553885,
0.019094473,
0.03994415,
0.03560933,
-0.022578284,
0.009673558,
-0.03667309,
-0.009686856,
0.04696496,
-0.011196063,
-0.04268333,
-0.07776078,
-0.019440195,
0.021089... | it has to be run before loading the model AutoModelForSeq2SeqLM.from_pretrained(model_name) |
[
0.022102863,
-0.0009794558,
-0.026284894,
-0.005035044,
-0.03635498,
0.024216525,
0.0021476313,
-0.0049897516,
-0.0011691191,
0.05441169,
-0.003763073,
-0.0041027684,
0.05042593,
-0.037351422,
0.012153555,
0.076997675,
-0.030572608,
-0.049761638,
-0.051392175,
-0.014584266,
0... |
deepspeed --num_gpus 2 t0.py
or:
python -m torch.distributed.run --nproc_per_node=2 t0.py
from transformers import AutoTokenizer, AutoConfig, AutoModelForSeq2SeqLM
from transformers.integrations import HfDeepSpeedConfig
import deepspeed
import os
import torch
os.environ["TOKENIZERS_PARALLELISM"] = "false" # To avoid... |
[
0.0145927295,
-0.0058431327,
-0.0008625417,
0.033696182,
-0.032810148,
-0.054370333,
0.03906609,
0.008934187,
-0.00551087,
0.031655617,
0.015519039,
-0.0009934333,
0.03487756,
-0.032514803,
-0.020539904,
0.045026693,
-0.0027453662,
-0.042422287,
-0.061646562,
0.029373406,
0.0... | - set offload_param.device to "none" or completely remove the offload_param section if you don't
- want CPU offload
- if using offload_param you can manually finetune stage3_param_persistence_threshold to control
- which params should remain on gpus - the larger the value the smaller the offload size |
[
0.042762347,
0.014900386,
-0.022248894,
-0.006904478,
-0.022384474,
-0.044877414,
-0.011734563,
0.014886828,
0.016446013,
0.01937457,
-0.039725326,
0.010988865,
0.026655287,
0.010832947,
-0.011524412,
0.013795398,
0.022153987,
-0.059167683,
-0.055696804,
0.023238637,
-0.01386... | Save the script as t0.py and launch it: |
[
0.040161274,
-0.0015785976,
0.0054941033,
-0.01095904,
-0.054248344,
-0.00047439957,
-0.014823506,
0.002898349,
-0.0104996795,
0.047831874,
-0.0053264,
0.042757027,
0.031586535,
-0.07314777,
-0.007787262,
0.06918122,
-0.008552864,
-0.00034429287,
-0.057077423,
0.00008168696,
... | the full DeepSpeed config file
the command line arguments of the [Trainer], or [TrainingArguments] arguments if you're scripting the [Trainer] setup yourself (don't dump the [TrainingArguments] which has dozens of irrelevant entries)
the outputs of:
python -c 'import torch; print(f"torch: {torch.__version__}")'
pyth... |
[
0.016063927,
0.0084871575,
-0.018134324,
0.010065651,
-0.027238194,
-0.026724266,
0.03459471,
0.017444192,
0.006710434,
0.05603286,
-0.014074291,
0.0011535853,
0.061260242,
-0.05615033,
-0.00019845887,
0.044227194,
0.022906514,
-0.027311612,
-0.081817366,
-0.009786662,
0.0282... |
$ deepspeed --num_gpus 2 t0.py
rank0:
in=Is this review positive or negative? Review: this is the best cast iron skillet you will ever buy
out=Positive
rank1:
in=Is this review positive or negative? Review: this is the worst restaurant ever
out=negative
This is a very basic example and you'll want to adapt ... |
[
0.005795404,
0.010363372,
-0.011289461,
-0.0061224746,
-0.028120754,
0.018051378,
-0.0025687935,
0.01863937,
0.018948067,
0.066913575,
0.0041784234,
-0.0145675205,
0.032104407,
-0.067148775,
0.02103544,
0.061504044,
-0.0009940753,
-0.044511054,
-0.0813782,
-0.029928831,
0.044... |
otherwise the model will first be loaded normally and only partitioned at forward time which is
less efficient and when there is little CPU RAM may fail
dschf = HfDeepSpeedConfig(ds_config) # keep this object alive
now a model can be loaded.
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
initialise Deepsp... |
[
0.0090295635,
0.0039156303,
0.02386737,
0.022965118,
-0.012053516,
-0.018425666,
0.015140907,
0.011264046,
0.0038063733,
0.06778164,
0.0074506234,
-0.002821298,
0.023049705,
-0.010700138,
-0.03936072,
0.020779978,
-0.009896571,
-0.034370143,
-0.019779043,
-0.017833564,
0.0255... | a link to a Google Colab notebook to reproduce the issue
if impossible, a standard and non-custom dataset we can use and also try to use an existing example to reproduce the issue with |
[
0.008947689,
-0.010714339,
0.00313634,
0.008432714,
-0.03936697,
-0.01622171,
0.006587387,
-0.00889047,
0.007896282,
0.06362801,
-0.01281,
-0.0019722823,
0.05856409,
-0.053814877,
-0.015177455,
0.06254084,
0.01958335,
-0.047778226,
-0.063914105,
-0.010964674,
0.022573067,
-... |
The following sections provide a guide for resolving two of the most common issues.
DeepSpeed process killed at startup
When the DeepSpeed process is killed during launch without a traceback, that usually means the program tried to allocate more CPU memory than your system has or your process tried to allocate more C... |
[
0.02271333,
0.024002029,
-0.006703434,
0.000702927,
-0.015581548,
-0.030284438,
0.010111898,
0.020399528,
-0.01789535,
0.07989937,
-0.0065277023,
-0.0032894788,
0.03494133,
-0.0455731,
-0.0025224828,
0.07902071,
-0.008193493,
-0.035468526,
-0.05749357,
-0.009511481,
0.0202091... |
0%| | 0/189 [00:00<?, ?it/s]
[deepscale] OVERFLOW! Rank 0 Skipping step. Attempted loss scale: 262144, reducing to 262144
1%|▌ ... |
[
0.044542342,
0.016015772,
-0.026725404,
-0.014555366,
-0.029670555,
-0.045369904,
0.02524066,
-0.01098346,
-0.017865617,
0.023196094,
0.025751801,
0.017841276,
0.01910696,
-0.045296885,
0.0034775885,
0.0046337424,
0.0038670297,
-0.03485499,
-0.058854308,
-0.008604217,
0.00558... | ZeRO: Memory Optimizations Toward Training Trillion Parameter Models
ZeRO-Offload: Democratizing Billion-Scale Model Training
ZeRO-Infinity: Breaking the GPU Memory Wall for Extreme Scale Deep Learning |
[
0.09556142,
0.030994443,
-0.002812631,
0.041134953,
0.0045832815,
0.00259958,
0.034718357,
-0.021097418,
0.009675021,
0.015540189,
0.013284355,
-0.0013973638,
-0.007240153,
-0.041879736,
-0.017215952,
0.014423015,
-0.0065920483,
-0.01330584,
-0.015583158,
-0.017659957,
0.0043... | Optimizing LLMs for Speed and Memory
[[open-in-colab]]
Large Language Models (LLMs) such as GPT3/4, Falcon, and Llama are rapidly advancing in their ability to tackle human-centric tasks, establishing themselves as essential tools in modern knowledge-based industries.
Deploying these models in real-world tasks remains ... |
[
0.04528957,
0.02158331,
-0.023632545,
-0.0050088316,
-0.022703756,
0.023146035,
0.008366481,
-0.027067594,
0.0014337274,
0.06504478,
0.007599861,
-0.016202224,
-0.028335465,
-0.029603338,
0.0013507997,
0.020684006,
-0.0041168984,
-0.039480947,
-0.02436968,
-0.012398609,
0.025... | The crux of these challenges lies in augmenting the computational and memory capabilities of LLMs, especially when handling expansive input sequences.
In this guide, we will go over the effective techniques for efficient LLM deployment:
Lower Precision: Research has shown that operating at reduced numerical precision,... |
[
0.061331145,
-0.0061626276,
-0.00008267636,
0.026955348,
0.010203119,
0.012051205,
0.017932756,
0.00096444774,
0.01199499,
0.037945483,
0.041177876,
-0.012845249,
-0.01491117,
-0.038086023,
0.00004438502,
0.014925224,
0.0067564044,
-0.01893058,
-0.022697022,
-0.035809293,
0.0... | To exhibit near-human text understanding and generation capabilities, LLMs currently require to be composed of billions of parameters (see Kaplan et al, Wei et. al). This consequently amplifies the memory demands for inference.
In many real-world tasks, LLMs need to be given extensive contextual information. This neces... |
[
0.019614702,
0.005730846,
-0.023976821,
-0.046291884,
-0.032730736,
-0.011795528,
0.012967662,
-0.017418804,
-0.047152437,
0.062494043,
0.018665124,
-0.01027472,
-0.012693175,
-0.042493574,
0.0045067817,
-0.009213865,
-0.011187205,
-0.032226272,
-0.031336043,
-0.01137267,
0.0... | Lower Precision: Research has shown that operating at reduced numerical precision, namely 8-bit and 4-bit can achieve computational advantages without a considerable decline in model performance.
Flash Attention: Flash Attention is a variation of the attention algorithm that not only provides a more memory-efficient a... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.