memory optimization is crucial during training with the growing complexity of deep learning models and large-scale computations. deepspeed provides memory-saving techniques such as offloading, gradient checkpointing, and zero. developers can train models of such gigantic sizes based on memory-saving techniques within the standard hardware. additionally, these techniques give the ability to train models that were hitherto limited by hardware limits.

deepspeed has made impressive strides in not just the realms of research but equally so in industry domains and hence is an irreplaceable tool for deep learning practitioners. it means by such strategies, you can make your model consume less memory and actually push out the limits of your hardware.

why memory optimization?

memory optimization forms part of the most critical components in training deep learning models. under such parameters as billions, like gpt and bert, effective memory management must be at work while training on available hardware. deepspeed is an open-source library for training deep learning models featuring zero-optimizer, offloading techniques, and gradient checkpointing to avoid major utilization in training.

memory issues in deep learning

deep learning models' size and complexity have recently increased. such massive models need a vast amount of memory to train. deepspeed, developed by microsoft as a deep learning optimization library, presented powerful solutions to the challenges.

deep learning models are a bit of art as they represent something as new as the memory-related issues that pop up as the models' size grows. some of the most common memory-related issues include:

model parameters − large models, such as gpt-3, have hundreds of billions of parameters and, thus, require much memory to store.
gradients − the gradients for computing every parameter during training also have to be calculated and kept in memory, which consumes a lot more.
activation maps − all the intermediate values resulting during the forward pass need to be stored until the back passes only for gradient computation, which is called activation maps.
batch sizes − larger batch sizes increase convergence speeds but consume more memory.
data parallelism − bifurcation of the data among several gpus is a great strategy to cut down the training time but, undoubtedly, it does gobble up a lot of memory unless it is kept in control.

unless those pitfalls are identified, training large models becomes impossible even on consumer-grade hardware. deepspeed conquers these by using innovative memory-saving techniques.

deepspeed's memory optimization techniques

there is more than one way deepspeed has for the optimization of memory usage when the models are trained. some methods include zero, which stands for zero redundancy optimizer, gradient checkpointing, and activation recomputations.

zero redundancy optimizer (zero)
gradient checkpointing
offloading techniques

1. zero redundancy optimizer (zero)

zero is mainly concerned with memory optimization at the point where redundant copies of the optimizer's state, gradients, and model parameters are removed. zero moves through these three phases:

stage 1 − sharding optimizer states across gpus, with each gpu storing a portion of the optimizer state.
stage 2 − further reduction of memory as gradients are sharded across gpus.
stage 3 − model parameters are sharded, and now models can be trained up to a trillion parameters.

example

import deepspeed

model = mymodel()  # your dl model
optimizer = torch.optim.adam(model.parameters(), lr=1e-4)

# deepspeed configuration for zero
ds_config = {
 "train_batch_size": 8,
 "zero_optimization": {
    "stage": 2,   # adjust the stage of zero here
    "allgather_partitions": true,
    "reduce_scatter": true,
    "allgather_bucket_size": 5e8,
    "overlap_comm": true,
    "contiguous_gradients": true
 }
}
# initialize deepspeed
model_engine, optimizer, _, _ = deepspeed.initialize(
  model=model,
  optimizer=optimizer,
  config_params=ds_config
)

# training loop
for batch in train_dataloader:
    loss = model_engine(batch)
model_engine.backward(loss)
model_engine.step()

you'll notice that memory usage is much lower, especially for large models. a memory profiler can then highlight where the zero optimization kicks in.

2. gradient checkpointing

gradient checkpointing gives you reduced memory by not storing activations during the forward pass in the buffer. these are instead reconstructed on the backward pass, sacrificing a bit of computing to save some memory.

example

import torch
from torch.utils.checkpoint import checkpoint

def custom_forward(*inputs):
    return model(*inputs)

# gradient checkpointing
outputs = checkpoint(custom_forward, input_data)
loss = criterion(outputs, labels)
loss.backward()

in this case, memory saved will depend on the size of intermediate activations.

3. offloading techniques

deepspeed also provides offloading of another form. it lets you move parts of your model, like optimizer states and gradients, to the cpu or even nvme storage, freeing gpu memory for a different usage.

cpu offloading

deepspeed lets us offload optimizer states and gradients to the cpu. that also frees up that precious gpu memory. that can be really useful in case one has limited memory on the gpu but quite a bit of memory on the cpu.

example

ds_config = {
    "train_batch_size": 8,
    "zero_optimization": {
        "stage": 2,
        "offload_optimizer": {
            "device": "cpu",
            "pin_memory": true
        },
        "offload_param": {
            "device": "cpu",
            "pin_memory": true
        }
    }
}
model_engine, optimizer, _, _ = deepspeed.initialize(
   model=model,
   optimizer=optimizer,
   config_params=ds_config
)

because transfer offloading to the cpu involves a cost with respect to inter-device, the training is relatively slow but at model sizes that otherwise wouldn't have fit on memory-constrained gpus.

nvme offloading

this is not enough yet for big models. deepspeed also offloads optimizer states and gradients to the nvme storage. this will increase the scale of the models that can teach even in addition.

example

ds_config = {
    "train_batch_size": 8,
    "zero_optimization": {
        "stage": 2,
        "offload_optimizer": {
            "device": "nvme",
            "nvme_path": "/local_nvme"
        },
        "offload_param": {
            "device": "nvme",
            "nvme_path": "/local_nvme"
        }
    }
}
model_engine, optimizer, _, _ = deepspeed.init(
   model=model,
   optimizer=optimizer,
   config_params=ds_config
)

offloading using nvme will enable the training of massive models, though the rate will largely rely on the i/o speed of the nvme drive.

memory optimization case studies

let's discuss some real-life case studies of memory optimization using deepspeed −

case study 1: training gpt-2 using zero optimization

using deepspeed, a research team scaled the training of this 1.5 billion parameter gpt-2 model down to consumer-grade gpus. with zero stage 3, it was possible to train it on 4 nvidia rtx 3090 gpus, with a total of 24 gb of memory per gpu. had it not been possible to do this using zero, training would have been impossible due to the model's requirement for more than 50 gb of memory per gpu.

case study 2: offloading with nvme for a 175b parameter model

microsoft leveraged deepspeed's offloading ability and trained a 175 billion parameter model on a cluster of gpus with limited memory. the use of close to no memory bottlenecks for offloading optimizer states and parameters during training of the model shows how offloading can make way for super-large models even when gpu resources are limited.

Save or share this article