deep learning models are becoming increasingly complex with rising training computational costs. deepspeed, developed by microsoft, efficiently trains large-scale models on minimum resources. this chapter will take you through basic steps that get them up and running with deepspeed in a flow from installation and setting up of the environment to running their first model.

installing deepspeed

the first thing we need to do is install the library before digging further into the details of deepspeed. using pip, this is simple to accomplish −

pip install deepspeed

while installing, you may see the result something like below −

collecting deepspeed
downloading deepspeed-0.6.0-py3-none-any.whl (696 kb)
|| 696 kb 3.2 mb/s 
collecting torch
downloading torch-1.9.1-cp38-cp38-manylinux1_x86_64.whl (804.1 mb)
||
deepspeed-0.6.0 torch-1.9.1 installed successfully

you can also clone the github repository and install from the source, if you so desire −

git clone https://github.com/microsoft/deepspeed.git
cd deepspeed
pip install .

this will give you the latest features, which might not be released yet in the stable.

environment setup

after installing deepspeed, one has to set up the environment. first, make sure that all the required dependencies are present.

create a virtual environment for managing the dependencies −

python -m venv deepspeed-env
source deepspeed-env/bin/activate  # on windows, use 'deepspeed-env\\scripts\\activate'

install pytorch if you haven't already −

pip install torch torchvision torchaudio

further, depending on your use case, you might need cuda or other types of acceleration for gpus. if you are on a machine with gpus, installation of the cuda version of pytorch is as simple as running the following in your terminal −

pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu113

this will ensure the setup so that deepspeed uses all your machine's hardware capabilities.

basic concepts and terminology

before running your first model, let's cover some basic concepts and terminology that you will encounter quite frequently in deepspeed.

optimizer − deepspeed currently supports multiple optimizers that can be used to optimize the training of large models. the optimizer handles the gradient update while training the model.
scheduler− schedulers update the learning rate during training. by default, deepspeed integrates all pytorch schedulers and further provides additional custom schedulers developed for large models.
zero redundancy optimizer (zero) − it is a memory optimization technique that reduces the memory footprint of large models by partitioning the model states across many gpus.
accumulate gradients − this can facilitate the use of larger batch sizes than allow gpu memory by summing gradients over multiple iterations before model weight updates.
checkpoint activations − this saves some memory at the cost of additional computation, recomputing the forward pass activations during back-propagation.

understanding these concepts should provide you context enough to go through most of the advanced features in deepspeed and customize your training pipeline.

running your first model with deepspeed

now that your environment is set up and you are familiar with basic terminology, let's run a simple deepspeed model. we will first create a basic pytorch model and then add deepspeed to it to see performance gains.

step 1: create a simple pytorch model

import torch
import torch.nn as nn
import torch.optim as optim

class simplemodel(nn.module):
def __init__(self):
super(simplemodel, self).__init__()
self.fc1 = nn.linear(10, 50) # input layer (10) -> hidden layer (50)
self.fc2 = nn.linear(50, 1) # hidden layer (50) -> output layer (1)

def forward(self, x):
x = torch.relu(self.fc1(x)) # hidden layer activation function
x = self.fc2(x)
return x

model = simplemodel()

step 2: implement deepspeed

now, let's refactor the code so it works with deepspeed. we will initialize the model with deepspeed and some basic configuration.

import deepspeed

ds_config = {
   "train_batch_size": 32,
   "fp16": {
      "enabled": true
   },
   "zero_optimization": {
      "stage": 1
   }
}

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

output

if all goes well, deepspeed will initialize and print out the configuration settings −

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

step 3: train model

at this point, you should now be able to train your model using deepspeed. below is an example training loop.

for epoch in range(5) − 
inputs = torch.randn(32, 10)
labels = torch.randn(32, 1)

model_engine.train()
outputs = model_engine(inputs)
loss = nn.mseloss()(outputs, labels)

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

output

each epoch will give you a result something like this:

epoch 1, loss: 0.4857
epoch 2, loss: 0.3598
epoch 3, loss: 0.2893
epoch 4, loss: 0.2194
epoch 5, loss: 0.1745

step 4: save the model

finally, you can save the model that is so far trained −

model_engine.save_checkpoint('./checkpoint', epoch=5)

output

[info] saving model checkpoint to ./checkpoint

advanced capabilities of deepspeed

let's now look into some advanced capabilities of deepspeed, having had a basic view of what deepspeed is. these advanced features are implemented to deal with the complexity of training large models, reducing memory consumption, and improving computation efficiency.

mixed precision training fp16 − one of the reasons for fast model training in deepspeed is that it supports mixed precision training by using half precision.
zero optimization stages − deepspeed has a game-changing technique known as zero, which reduces memory by partitioning model states across multiple gpus.
gradient accumulation − another strategy that deepspeed supports is gradient accumulation, which can simulate larger batch sizes without requiring more gpu memory.
offloading − even for very large models, optimizations provided by zero stage 3 may be insufficient.

summing up

the major steps that form part of getting started with deepspeed are installation of the library, setup of your environment, knowing some basic concepts, and running your first model. deepspeed allows the training of large models with much higher efficiency at higher memory and lower overall training time. this basic chapter will enable you to go further into the advanced features of deepspeed in driving your deep learning projects.

Save or share this article