TRAINING

The main agenda of the workshop is to make you familiar with CUDA programming on Drive PX2 to exploit computational capabilities of the GPUs on Drive PX2. This lab includes:
1) Demonstration of effective usage of unified memory, zero copy, global memory in an application.
2) We will also demonstrate the performance of dp4A, dp2A intrinsic which are supported on discrete GPU in Drive PX2.
3) Optimization using CUDA streams to overlap memory transfer and kernel execution.

Within this self-paced DLI lab, we turn MobileNet – an adjustable classification network topology – into a Fully Convolutional Network that will be trained on CamVid – a practicable Semantic Segmentation dataset. Having in mind a computational budget (e.g., 30% of DRIVE PX 2's integrated GPU) and a specific use case (e.g., running Semantic Segmentation inference at 30 fps for two cameras in parallel), several design choices that can already be made before starting the training phase. The expected outcome of this session is a trained neural network whose architecture has previously been adjusted through guided choices taken by the participants.

Prerequisites: Python and Linux knowledge, hands-on experience with common CNN topologies.

NVIDIA TensorRT is a high-performance neural network inference engine for production deployment of deep learning applications. This lab provides hands-on experience using TensorRT to convert the neural network model to INT8 precision, calibrate, vali date and deploy for inference in a self-driving car application.

In this lab we'll experience writing host-side code for CUDA programs in modern C++, elegantly.

Taking a sample program with a simple kernel, we'll make its code safer in handling errors and allocations; clearer to read; and shorter - without imposing any restrictions on the use of API features, and without loss of performance. We'll achieve this by gradually converting aspects of the C-style API to using a FOSS header-mostly wrapper library (https://github.com/eyalroz/cuda-api-wrappers), and more C++ idiomatic constructs.

The following kinds of code will definitely be covered:

(*) host- and device-side memory allocation
(*) Copying data
(*) Enqueuing launches and events on streams
(*) Streamlined error handling

as will additional API aspects or implementation details as time allows.

This lab explores three approaches to identify a specific feature within an image. Each approach is measured in relation to three metrics: model training time, model accuracy and speed of detection during deployment. On completion of this lab, you will understand the merits of each approach and learn how to detect objects using neural networks trained on NVIDIA DIGITS using real-world datasets.

This lab will show three approaches for deployment. The first approach is to directly use inference functionality within a deep learning framework, in this case NVIDIA DIGITS and Caffe. The second approach is to integrate inference within a custom application by using a deep learning framework API, again using Caffe, but this time through its Python API. The final approach is to use the NVIDIA TensorRT™, which will automatically create an optimized inference run-time from a trained Caffe model and network description file. In this lab, you will learn about the role of batch size in inference performance, as well as various optimizations that can be made in the inference process. You will also explore inference for a variety of different DNN architectures trained in other DLI labs.

In this hands-on tutorial we will do a deep dive into Deep Reinforcement Learning (DRL), a paradigm which has recently seen a lot of successes. We will introduce you to a variety of DRL algorithms, including Q-learning and Policy Gradient methods. Hopefully by the end, participants can take this knowledge and apply it to more complex and diverse problems.

There are a variety of important applications that need to go beyond detecting individual objects within an image, and that instead need to segment the image into spatial regions of interest. An example of image segmentation involves medical imagery analysis, where it is often important to separate the pixels corresponding to different types of tissue, blood or abnormal cells, so that you can isolate a particular organ. Another example includes self-driving cars, where segmenting an image into distinct areas is needed to understand road scenes. In this lab, you will learn how to train and evaluate an image segmentation network using TensorFlow.

In this introduction to natural language processing, you will use a recurrent neural network (RNN) to predict the next word of a sentence. You'll learn:
• how to preprocess textual data using one-hot encoding
• how factors like dictionary size, network depth, and other parameters affect performance
• to load data, train, and test RNNs

In order to solve large problems with Deep Learning, one type of network may not be enough. In this lab, you will combine the output of a convolutional neural network (CNN) with the input of a Recurrent Neural Network (RNN) to generate descriptions of scenes. You will:
- Examine the output of internal layers of CNNs
• Combine networks by concatenating vectors
• Interpret context in video data by using what you know about image features

This lab will use an object recognitionundefinedimage classification example to teach how to apply deep learning to practical problems. You will learn how to: import and manage large datasets; train, evaluate and compare different deep learning models; extract discriminative information from images, and; use transfer learning to fine-tune neural networks for new tasks. We will use the new MATLAB framework for deep learning and real-world examples including data used for ADAS and autonomous driving.

This lab will guide students through the process of training a Generative Adversarial Network (GAN) to generate image contents in DIGITS. After a quick review of the theory behind GANs we will train a GAN to generate images of handwritten digits using the MNIST dataset. We will create smooth animations of digits morphing across classes. In the second part of the lab we will apply these concepts on the CelebA dataset of celebrity faces. Using a pre-trained network we will see how to edit or retrieve face attributes (age, smile, etc.). We will see how to visualize the latent space in 3D and how to generate image analogies.

Learn how neural networks transfer the look and feel of one image to another image by extracting distinct visual features. See how convolutional neural networks are used for feature extraction, and feeds into a generator for painting a new resultant image. Explore the architectural innovations and training techniques used to make the transfer faster, look qualitatively better to humans and work with any arbitrary input style.

We will start with the basics of Neural Networks, such as Fully-Connected Layer, Embedding Layer and Recurrent Layers, for the purposes of text classification. Once classified, cognition of words will naturally lead to language processing, enabling Neural Works to understand language. This requires intermediate steps, such as TF-IDF representation, which will be covered in this lab. By combining newer techniques with classical methods for Natural Language Processing, we can achieve state-of-the-art results in text classification.

Learn how a neural network with an autoencoder can be used to dramatically speed up the removal of noise in ray traced images.

· Learn about noise in rendered images and decide whether images have noise or not
· Use a pre-trained network to denoise some sample images or your own images
· Train your own denoiser using the provided dataset
· Learn the differences between normal, RGB and Albedo channels
· Iterate and modify parameters to improve the quality of the denoiser

By the end of the lab you will have the tools and the knowledge to build your own AI accelerated denoiser.

Understanding sequences of words is key to many applications, including Machine Translation, Text Summarization, Conversational Modeling and Scene Captioning. Using the sequence-to-sequence (seq2seq) in TensorFlow, we will use real world data in applying AI to text generation. How the encoder-decoder architecture of seq2seq enables generation of words will be explained and shown through examples. We will also explore how newer Convolutional Neural Network based encoder can be used to build your own text generation engine.

This lab demonstrates an algorithmic trading strategy using a deep autoencoder based statistical arbitrage. It uses hierarchical, non-linear basis set that can be used to reconstruct security return data. Anomalous deviations (spreads) in reconstruction error are used as (mean reverting) signals for creating long/short positions. P&L of the strategy can be calculated. This course uses Keras with TensorFlow backend and Python for the code examples covered during the lab session.

After taking this lab, you will be able to:

• Structure and train a deep autoencoder in Keras with TensorFlow backend and Python.
• Use the autoencoder as an anomaly detector to create an arbitrage strategy
• Perform hyperparameter search over the autoencoder.
• Calculate P&L of the strategy

The goal of this lab is to give a guided tour through the essentials of CUDA parallelization in mathematical finance. We consider pricing a bullet option under LV (Local Volatility) model using either MC (Monte Carlo) or an implicit discretization scheme for PDE (Partial Differential Equation). The considered example is close to a real banking application with an LV model derived from the implicit SVI model of Gatheral & Jacquier using the Andersen & Brotherton-Ratcliffe expression based on Dupire equation. Several optimizations are studied like the judicious memory storage in shared and registers for two discretization scales in MC. Thanks to a simple trick proposed in Abbas-Turki & Graillat, we see also the use of PCR (Parallel Cyclic Reduction) to solve tridiagonal systems of any size.

Convolutional neural networks (CNNs) have proven to be just as effective in visual recognition tasks involving non-visible image types as regular RGB camera imagery. One important application of these capabilities is medical image analysis, where we wish to detect features indicative of medical conditions and use them to infer patient status. In addition to processing non-visible imagery, such as CT scans and MRI, these applications often require us to process higher dimensionality imagery that may be volumetric and have a temporal component. In this lab you will use the deep learning framework MXNet to train a CNN to infer the volume of the left ventricle of the human heart from a time-series of volumetric MRI data. You will learn how to extend the canonical 2D CNN to be applied to this more complex data and how to directly predict the ventricle volume rather than generating an image classification. In addition to the standard Python API, you will also see how to use MXNet through R, which is an important data science platform in the medical research community.

One important area of current research is the use of deep neural networks to classify or forecast time-series data. Time-series data is produced in large volumes from sensors in a variety of application domains including Internet of Things (IoT), cyber security, data center management and medical patient care. In this lab, you will learn how to create training and testing datasets using electronic health records in HDF5 (hierarchical data format version five) and prepare datasets for use with recurrent neural networks (RNNs), which allows modeling of very complex data sequences. You will then construct a long-short term memory model (LSTM), a specific RNN architecture, using the Keras library running on top of Theano to evaluate model performance against baseline data.