Posts

Slides: Distributed Training for ML

Explore distributed training techniques through this interactive presentation. Navigate through the slides using arrow keys or the navigation controls. Topics Covered Back to Basics: Understanding neural network fundamentals Why Distributed Training: Memory constraints and scaling challenges DDP (Data Distributed Parallel): Replicating models across GPUs Pipeline Parallelism: Splitting models across devices FSDP (Fully Sharded Data Parallel): Advanced sharding techniques Slides Use the arrow keys (← →) or click the navigation arrows to move between slides. Some slides include animations that you can step through using the animation controls at the bottom.

Wednesday, December 3, 2025 | 2 minutes Read

Distributed Training Techniques: DDP, Pipeline Parallelism, and FSDP

Modern deep learning models have grown exponentially in size and complexity. GPT-4 has over a trillion parameters, and even “smaller” models like LLaMA-70B require substantial computational resources. Training or fine-tuning such models on a single GPU is often impossible; not just because of time constraints, but because the model itself may not fit in the memory of a single device. This is where distributed training becomes essential. Why Do We Need Distributed Training? The Memory Wall Problem A modern GPU like the NVIDIA A100 has 80GB of memory. Sounds like a lot? Let’s do some math:

Monday, December 1, 2025 | 8 minutes Read

NICE- Non-linear Independent Components Estimation: Insights and Implementation in Keras

Keras implementation can be found here. Flow-based deep generative models have not gained much attention in the research community when compared to GANs or VAEs. This post discusses a flow-based model called NICE, its advantages over the other generative models and finally an implementation in Keras. While VAEs use an encoder that finds only an approximation of the latent variable corresponding to a datapoint, GANs doesnt even have an encoder to infer latents. In flow-based models, the latent variables can be infered exactly without any approximation. Flow-based models make use of reversible architecture (which will be explained below) which enables accurate inference, in addition to providing optimization over the exact log-likelihood of the data instead of a lower bound of it.

Tuesday, December 3, 2019 | 8 minutes Read

Implementing Variational Autoencoders: Insights and some tricks

This post is a summary of some of the main hurdles I encountered in implementing a VAE on a custom dataset and the tricks I used to solve them. The keras code snippets are also provided. Understanding VAEs and its basic implementation in Keras can be found in the previous post. Posterior collapse in VAEs The Goal of VAE is to train a generative model $\mathbb{P}(\mathbf{X}, z)$ to maximize the marginal likelihood $\mathbb{\mathbf{X}}$ of the dataset. The cost function used in training a VAE is comprised of a reconstruction loss and a KL loss as given below.

Wednesday, July 3, 2019 | 5 minutes Read

Understanding Variational Autoencoders and Implementation in Keras

Variational Autoencoders (VAEs)[Kingma, et.al (2013)] let us design complex generative models of data that can be trained on large datasets. This post is about understanding the VAE concepts, its loss functions and how we can implement it in keras. Generating data from a latent space VAEs, in terms of probabilistic terms, assume that the data-points in a large dataset are generated from a latent space. For e.g., let us assume we want to generate the image of an animal. First we imagine that it has four legs, a head and a tail. This is analogous to the latent space and from this set of characteristics that are defined in the latent space, the model will learn to generate the image of an animal.

Tuesday, July 2, 2019 | 10 minutes Read

Installing Kaldi with MKL support without root access

Kaldi has recently switched to Intel Math Kernel Libraries (MKL) for linear algebra operations (as of April 2019). However, installing MKL (by running tools/extras/install_mkl.sh) requires root access. This post details how kaldi (with MKL) can be installed without root access. Download Kaldi Download the MKL standalone installer from here. Extract the contents and launch the installer by running install.sh. When asked for the path to install, specify a location where you have write access (e.g., /home/<username>/intel) Complete the installation of MKL libraries Navigate to the kaldi folder kaldi/tools Typically the first step is to run extras/check_dependencies.sh. This will complain about the missing MKL libraries. This is because the script expects the MKL libraries to be located under /opt/intel directory. As of now (May 2019), there is no option to pass the mkl-root directory to this script. Therefore we will edit the extras/check_dependencies.sh script by changing /opt/intel/mkl/include/mkl.h to /home/<username>/intel/mkl/include/mkl.h. Then running extras/check_dependencies.sh should work fine without any MKL related warnings. Then run make -j <numcpu> to install the tools required by kaldi Navigate to the kaldi/src folder. Run ./configure with the --mkl-root option. ./configure --shared --mkl-root=/home/<username>/intel/mkl Then install kaldi using the usual steps make depend -j <numcpu> make -j <numcpu> This will install Kaldi with MKL support without requiring any root privileges.

Tuesday, May 21, 2019 | 1 minute Read

Training kaldi models with custom features

Kaldi Speech Recognition Toolkit is a freely available toolkit that offers several tools for conducting research on automatic speech recognition (ASR). It lets us train an ASR system from scratch all the way from the feature extraction (MFCC,FBANK, ivector, FMLLR,…), GMM and DNN acoustic model training, to the decoding using advanced language models, and produce state-of-the-art results. While kaldi offers so much flexibilty at every stage, sometimes we also need to play with features that are not offered by the kaldi repository. Kaldi makes use of ark format to store the features. If we want to perform experiments with customized features, they must be converted to the ark format first. The goal of this post is to explain how we can extract and store the custom features in the ark format using matlab and python.

Wednesday, March 6, 2019 | 10 minutes Read

Tracking Multiple Losses with Keras

Often we deal with networks that are optimized for multiple losses (e.g., VAE). In such scenarios, it is useful to keep track of each loss independently, for fine-tuning its contribution to the overall loss. This post details an example on how to do this with keras. Let us look at an example model which needs to trained to minimize the sum of two losses, say mean square error (MSE) and mean absolute error (MAE). Let $\lambda_{mse}$ be the hyperparameter that controls the contribution of MSE to the toal loss. i.e., the total loss is MAE + $\lambda_{mse}$ * MSE. This loss can be implemented using:

Monday, March 4, 2019 | 2 minutes Read

Tensorflow-GPU in multi-user environment

This post is intended for setting up tensorflow-gpu setup in a multi-user setting. This is written as a guide for GPU users at the WAVES research group, Ghent University, Belgium. But these are also applicable to any linux multi-user environment with GPU-based jobs. Installing Tensorflow in conda conda installation conda tensorflow Testing Tensorflow Installation Admin only Installing the cuda compiler and nvidia drivers Installing Tensorflow in conda conda installation Anaconda is a popular python environment among the AI/ML community. The anaconda distribution can be downloaded from here. Follow the instructions here to properly install it to your user account.

Sunday, January 27, 2019 | 5 minutes Read

Google Duplex

ഒരു കമ്പ്യൂട്ടർ നിങ്ങൾക്കുവേണ്ടി ഒരു ബാർബർ ഷോപ്പിലേക്കോ ഹോട്ടലിലേക്കോ ഫോൺ ചെയ്തു റിസർവേഷൻ എടുത്തുതരുന്ന കാലത്തെപ്പറ്റി നിങ്ങൾ ചിന്തിച്ചിട്ടുണ്ടോ? എങ്കിൽ അറിയുക, നാം അവിടെയെത്തിയെന്ന്! അതാണ് ഗൂഗിൾ ഡ്യൂപ്ളെക്സ് (Google Duplex) . ആർട്ടിഫിഷ്യൽ ഇന്റലിജൻസ് സീരീസ് ഭാഗം- 5 AI രംഗത്തെ ഏറ്റവും പ്രധാനപ്പെട്ട നാഴികക്കല്ലുകളിലൊന്നിനാണ് നമ്മൾ ഇന്നലെ സാക്ഷ്യം വഹിച്ചത്. നമുക്കുവേണ്ടി ഫോൺ കാളുകൾ നടത്താനും അവിടെയുള്ളവരോട് സംസാരിക്കാനും കഴിയുന്ന AI സംവിധാനമായ Google Duplex ഇന്നലെ ഗൂഗിൾ അവതരിപ്പിച്ചു (വീഡിയോ കാണുക). Google assistant കുറെ കാലമായി നമ്മൾ കണ്ടിരുന്നതാണെങ്കിലും അതിനു ധാരാളം പരിമിതികളുണ്ടായിരുന്നു. അതിൽനിന്നൊക്കെ വളരെയധികം മുന്നോട്ടുപോയ ഒരു മനുഷ്യൻതന്നെയെന്നു തോന്നിപ്പിക്കുമാറ് നമ്മുടെ സംസാരത്തിലെ ചെറിയ കാര്യങ്ങൾ വരെ (ഇടക്കുള്ള pause, hmmm, err ശബ്ദങ്ങൾ) ഉൾപ്പെടുത്തിയാണ് ഈ AI സംവിധാനം സംസാരിക്കുന്നത്!

Wednesday, May 9, 2018 | 3 minutes Read

ആർട്ടിഫിഷ്യൽ ഇന്റലിജൻസ് സീരീസ്: ഭാഗം - 4

ആർട്ടിഫിഷ്യൽ ഇന്റലിജൻസ് ഗവേഷണത്തിൽ ഇന്ന് ഏറ്റവുമധികം ഉപയോഗത്തിലിരിക്കുന്ന ന്യൂറൽ നെറ്റ്‌വർക്കുകളെ കുറിച്ചാണ് കഴിഞ്ഞ ഭാഗത്തിൽ പറഞ്ഞത് (കഴിഞ്ഞ ഭാഗം ഇവിടെ വായിക്കാം). ഇനി ചരിത്രത്തിലെ രണ്ടാം ഘട്ടത്തിലേക്ക്. മുമ്പുപറഞ്ഞതുപോലെ ന്യൂറൽ നെറ്റ്‌വർക്കുമായി ബന്ധപ്പെട്ട ആദ്യകാല ശ്രമങ്ങളും ഗവേഷണങ്ങളുമാണ് ഈ ഭാഗത്തിൽ. 1943 - ഇലെക്ട്രിക്കൽ സർക്യൂട്ടുകൾ ഉപയോഗിച്ച് ഒരു ന്യൂറൽ നെറ്റ്‌വർക്ക് നിർമ്മിക്കപ്പെട്ടു നമ്മുടെ ന്യൂറോണുകൾ എങ്ങനെയായിരിക്കും പ്രവർത്തിക്കുന്നത് എന്നതിനെപ്പറ്റി ന്യൂറോഫൈസിയോളജിസ്റ്റായ വാറൻ മക്കുല്ലോഷും ഗണിതജ്ഞനായ വാൾട്ടർ പിട്സും ചേർന്ന് ഒരു സിദ്ധാന്തം അവതരിപ്പിച്ചു. അതിന്റെ ഒരു ചെറിയ മോഡൽ ഇലെക്ട്രിക്കൽ സർക്യൂട്ടുകൾ ഉപയോഗിച്ച് അവർ നിർമിക്കുകയും ചെയ്തു. നമ്മുടെ ശരീരത്തിലെ ന്യൂറോണുകളുടെ പ്രവർത്തനത്തെപ്പറ്റി അനുലഭ്യമായിരുന്ന പരിമിതമായ അറിവുവച്ചാണ് അത്തരമൊരു മാതൃക അവർ നിർമ്മിച്ചത്. 1952- checkers game കളിക്കുന്ന കമ്പ്യൂട്ടർ

Tuesday, April 24, 2018 | 3 minutes Read

ആർട്ടിഫിഷ്യൽ ഇന്റലിജൻസ് സീരീസ്: ഭാഗം - 3

ന്യൂറൽ നെറ്റ്‌വർക്കുകൾ 1950 കൾക്ക് മുൻപുള്ള, ഇന്നത്തെ കമ്പ്യൂട്ടർ സയൻസിന്റെയും ആർട്ടിഫിഷ്യൽ ഇന്റലിജൻസിന്റെയും വളർച്ചക്ക് വിത്തുപാകിയ ചില സിദ്ധാന്തങ്ങളാണ് കഴിഞ്ഞ ഭാഗത്തിൽ പറഞ്ഞത്. അത്തരം സിദ്ധാന്തങ്ങളിൽ നിന്നും പ്രചോദനമുൾക്കൊണ്ട് പ്രവർത്തിക്കുന്ന യന്ത്രങ്ങൾ 1950 കൾക്ക് ശേഷമാണ് യാഥാർഥ്യമായത്. അന്നുമുതൽ 2006 വരെയുള്ള കാലമാണ് AI ചരിത്രത്തിലെ രണ്ടാം ഘട്ടം. അതിലേക്കു കടക്കുന്നതിനുമുന്പ് നമ്മൾ ന്യൂറൽ നെറ്റ്‌വർക്ക് എന്താണെന്ന് മനസിലാക്കേണ്ടതുണ്ട്. കൃത്രിമബുദ്ധി അഥവാ AI എന്നത് മഷിനുകൾക്കു മനുഷ്യനെപ്പോലെ ചിന്തിക്കാനുള്ള ബുദ്ധി കൃത്രിമമായി നിർമിക്കുന്ന പ്രക്രിയയാണ്. നമ്മുടെ തലച്ചോറിനെയും, അതിലേക്കു ബന്ധപ്പെട്ടിരിക്കുന്ന, നമ്മുടെ ഇന്ദ്രിയങ്ങളിൽനിന്നും സിഗ്നലുകൾ അവിടേക്കെത്തിക്കുന്ന ന്യൂറോണുകളെയും അടിസ്ഥാനപ്പെട്ടാണ് നമ്മുടെ ബുദ്ധി ഇരിക്കുന്നത്. നമ്മുടെ തലച്ചോറിൽ 100 ബില്യണിലധികം ന്യൂറോണുകൾ ഉണ്ടെന്നാണ് കണക്ക്. നമ്മുടെ ഇന്ദ്രിയങ്ങളിൽ നിന്നും വരുന്ന ഇത്തരം കോടിക്കണക്കിനു സിഗ്നലുകളെ ക്രോഡീകരിച്ചാണ് നമ്മുടെ തലച്ചോറ് സംവേദനം (പെർസെപ്ഷൻ) എന്നത് സാധ്യമാക്കുന്നത്. ഉദാഹരണം പറഞ്ഞാൽ, നാം ഒരാളെ കാണുമ്പോൾ അയാളിൽനിന്നും വരുന്ന പ്രകാശകിരണങ്ങൾ നമ്മുടെ കണ്ണിൽ പതിക്കുകയും ആ കിരണങ്ങൾക്കനുസൃതമായി കണ്ണിൽ നിന്നും സിഗ്നലുകൾ തലച്ചോറിലേക്ക് ന്യൂറോണുകൾ എത്തിക്കുകയും ചെയ്യും. ഈ സിഗ്നലുകളിൽ നിന്നാണ് നമ്മുടെ തലച്ചോറ് നാം ആ ആളെ കണ്ടു എന്ന തോന്നൽ അല്ലെങ്കിൽ perception ഉണ്ടാക്കുന്നത്. കാഴ്ചക്ക് തലച്ചോറിലെ visual cortex എന്ന ഭാഗമാണ് പ്രധാനമായും ഉപയോഗിക്കുന്നത്. നമ്മുടെ തലച്ചോറ് ന്യൂറോണുകളിൽനിന്നും വരുന്ന സിഗ്നലുകളെ എങ്ങനെ ക്രോഡീകരിക്കുന്നു എന്നത് ഇന്നും നമുക്കധികം മനസിലാകാത്ത വിഷയമാണ്. അത് അറിയില്ലാത്തതുകൊണ്ടാണ് AI തീരുമാനങ്ങൾ (decision making ) എടുക്കാൻ മറ്റു സങ്കേതങ്ങൾ ഉപയോഗിക്കുന്നതും. (മറ്റു സങ്കേതങ്ങളെ പറ്റി വരും ഭാഗങ്ങളിൽ പറയാം)

Monday, April 16, 2018 | 3 minutes Read