deep learning models have grown big and complicated, making the training process even more difficult to carry out effectively. that is where deepspeed-deep learning optimization library from microsoft comes in. the library was destined for the training of big models; it also boasts a collection of features aimed at memory optimization, computational efficiency, and overall training performance. objectives by the end of this chapter will include training with deepspeed, looking at configuration files that set up the optimization features, and giving some examples of training popular models using this power tool.

deep learning model training with deepspeed

training deep learning models is a compute-bound task, especially when working on large datasets and complex architectures. deepspeed is built for this challenge by providing a set of capabilities comprising mixed precision training, zero (zero redundancy optimizer), and gradient accumulation all in one framework that ensures extremely high efficiency while scaling up model training without necessarily exponentially scaling computation resources.

now we will start by implementing deepspeed into a simple model training pipeline.

step 1: model and dataset

assume that a simple pytorch model is solving the regression problem:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import dataloader, tensordataset

# a simple regression model
class regressionmodel(nn.module):
    def __init__(self):
        super(regressionmodel, self).__init__()
        self.fc1 = nn.linear(10, 50)
self.fc2 = nn.linear(50, 1)
def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# generating synthetic data
inputs = torch.randn(1000, 10)
targets = torch.randn(1000, 1)
dataset = tensordataset(inputs, targets)
dataloader = dataloader(dataset, batch_size=32, shuffle=true)

model = regressionmodel()

step 2: add deepspeed

next step is to add deepspeed to your configuration file to enable training optimization.

deepspeed configuration files

deepspeed configuration files are json files, which specify a number of parameters in optimizing model training. an example is as follows:

{
    "train_batch_size": 32,
    "fp16": {
        "enabled": true
    },
    "zero_optimization": {
        "stage": 1,
        "allgather_partitions": true,
        "reduce_scatter": true,
        "allgather_bucket_size": 2e8,
        "overlap_comm": true
    },
    "optimizer": {
        "type": "adam",
        "params": {
            "lr": 0.001,
            "betas": [0.9, 0.999],
            "eps": 1e-8,
            "weight_decay": 3e-7
        }
    }
}

save the preceding text to a file in your project folder called ds_config.json.

step 3: deepspeed initialization

this is where things get interesting. with a configuration file setup, you're ready to initialize deepspeed in your training script as follows:

import deepspeed

# initialize deepspeed
ds_config_path = "ds_config.json"
model_engine, optimizer, _, _ = deepspeed.initialize(
    model=model,
    model_parameters=model.parameters(),
    config=ds_config_path
)

output

running the above code will initialize deepspeed with the config specified below −

[info] deepspeed info: version=0.6.0, git-hash=unknown, git-branch=unknown
[info] initializing model parallel group with size 1
[info] initialize optimizer with deepspeed zero optimizer

optimizing training with deepspeed's features

deepspeed comes with a set of features that could optimize model training. we will discuss some of the key features here in.

mixed precision training − it trains the models in 16-bit floating-point representation, hence requiring less memory and therefore faster computations.
zero optimization − the zero redundancy optimizer (zero) can substantially reduce the memory footprint for large models by partitioning model states across thousands of gpus. you can control how much optimization is done with the value of the stage parameter in the zero_optimization section.
gradient accumulation − this feature allows increasing the effective batch size without needing a proportional increase of gpu memory. you can enable gradient accumulation by setting the value for gradient_accumulation_steps in the config file.
activation checkpointing − this approach is a computation versus memory saving approach since it saves memory at the cost of recomputing some activations in the backward pass. that means it reduces overall memory consumption at train time.

these features can be combined in various ways depending on what is optimal for your particular requirements.

example of training bert model using deepspeed

demonstrating the power of deepspeed, take the training of a famous model like bert − bidirectional encoder representations from transformers.

step 1: prepare and load the bert model

you can load a pre-trained bert model using the hugging face transformers library easily −

from transformers import bertforsequenceclassification, berttokenizer

tokenizer = berttokenizer.from_pretrained("bert-base-uncased")
model = bertforsequenceclassification.from_pretrained("bert-base-uncased")

# sample data
inputs = tokenizer("deepspeed makes bert training efficient!", return_tensors="pt")
labels = torch.tensor([1]).unsqueeze(0)

# dataloader
dataloader = dataloader([(inputs, labels)], batch_size=1)

step 2: add deepspeed integration

as before, we add deepspeed integration by initializing with your model and config file −

model_engine, optimizer, _, _ = deepspeed.initialize(
    model=model,
    model_parameters=model.parameters(),
    config="ds_config.json"
)

step 3: run model

the the model as follows −

for batch in dataloader:
        inputs, labels = batch
        outputs = model_engine(**inputs)
loss = nn.crossentropyloss()(outputs.logits,labels)

        model_engine.backward(loss)
        model_engine.step()
print(f"epoch {epoch+1}, loss: {loss.item()}")

output

training bert with deepspeed will output the loss for every epoch, assuring us that the model is being trained efficiently −

epoch 1, loss: 0.6785
epoch 2, loss: 0.5432
epoch 3, loss: 0.4218

handling large datasets with deepspeed

large datasets pose problems that go well beyond model architecture. how you manage memory and computational resources efficiently while processing big volumes of data will save you from bottlenecks. deepspeed tackles these very challenges through its advanced features in the domain of data handling.

1. dynamic data loading

deepspeed performs dynamic loading of the data, thereby loading into memory only the batches being used at one time during training. this cuts down on the memory footprint, hence allowing you to train on more substantial datasets without necessarily needing more powerful hardware. besides that, you will keep the memory usage minimal; hence, you minimize the time taken by input/output operations of data, which enhances the overall speed of training.

2. data parallelism

another important capability enabled by deepspeed is that of data parallelism. it supports natively distributed data across many gpus. because of that, different batches can be processed at once. this parallel will speed up the training process. it can occupy gpu resources efficiently. therefore, in practice, applying data parallelism using deepspeed to your training pipeline is not painful because it's integrated into pytorch's dataloader.

3. memory-efficient data shuffling

large datasets normally require shuffling to avoid overfitting and learning by pattern based on how data has been ordered. however, this is extremely memory-consuming for large datasets. deepspeed optimizes this process using very memory-efficient algorithms able to provide effective shuffling without a huge memory increase. this makes sure that on large datasets, training will be smooth and efficient.

4. data augmentation support

data augmentation in general includes certain methods that increase the size of a dataset artificially by modifying existing data. deepspeed supports on-the-fly data augmentation, which means one doesn't have to store augmented data in memory but can perform data augmentation on the fly during training. this can reduce the memory pressure even further and also provide much more extensive utilization of data augmentation techniques.

5. batch size scaling

with deepspeed gradient accumulation and zero optimization, that allows scaling up of batch sizes even when working with enormous datasets. larger batch sizes can sometimes improve model convergence and training stability. deepspeed is enabled, which allows scaling of batch size with management of the gpu memory requirement; hence, your model should be able to train on big datasets effectively.

the above deepspeed features help in that aspect by being able to manage a large dataset, thus making it possible for you to design and train high-performance models with no hardware restrictions. whether you're training your model on a very big corpus of text or processing images in super-high resolution, this feature in handling data by deepspeed keeps your training pipeline optimized and scalable.

summing up

deepspeed allows having an effective training framework for deep learning models, especially in scaling size and complexity. therefore, learning advanced features of how to use mixed precision training, zero optimization, and activation checkpointing are ways in which added value optimizes the process. this chapter has information about model training using deepspeed preparing the environment for deepspeed, the configuration of deepspeed, and running the training processes. with this tool and technique in hand, now you can handle large-scale deep-learning projects with better performance and low consumption of resources.

Save or share this article