Course Information
Registration period
Year-round Recruitment
Course Level
Study Mode
Duration
7 Hour(s) 29 Minute(s)
Language
English
Taught by
Brad Klingensmith
Rating
2 views
Course Overview
Photorealistic image generation with Python and TensorFlow 2.0
This course covers the fundamentals necessary for a state-of-the-art GAN. Anyone who experimented with GANs on their own knows that it's easy to throw together a GAN that spits out MNIST digits, but it's another level of difficulty entirely to produce photorealistic images at a resolution higher than a thumbnail.
This course comprehensively bridges the gap between MNIST digits and high-definition faces. You'll create and train a GAN that can be used in real-world applications.
And because training high-resolution networks of any kind is computationally expensively, you'll also learn how to distribute your training across multiple GPUs or TPUs. Then for training, we'll leverage Google's TPU hardware for free in Google Colab. This allows students to train generators up to 512x512 resolution with no hardware costs at all.
The material for this course was pulled from the ProGAN, StyleGAN, and StyleGAN 2 papers which have produced ground-breaking and awe-inspiring results. We'll even use the same Flicker Faces HD dataset to replicate their results.
Finally, what GAN course would be complete without having some fun with the generator? Students will learn not only how to generate an infinite quantity of unique images, but also how to filter them to the highest-quality images by using a perceptual path length filter. You'll even learn how to generate smooth interpolations between two generated images, which make for some really interesting visuals.
Course Content
- 10 section(s)
- 57 lecture(s)
- Section 1 Introduction
- Section 2 Architecture
- Section 3 Weight Scaling
- Section 4 Resampling
- Section 5 Combined Resampling + Convolution
- Section 6 Minibatch Standard Deviation
- Section 7 PixelNorm and Image Conversion
- Section 8 Model Code
- Section 9 Loss and Training Step
- Section 10 Using a TPU With a Distributed Strategy
What You’ll Learn
- Create a GAN capable of generating high resolution images using TensorFlow 2.0
- Distribute training on a TPU or multiple GPUS
- Implement the R2 loss function
- Implement a scaled convolutional layer
- Implement up-sampling and down-sampling layers
- Implement mini-batch standard deviation to capture dataset variation
- Generate infinite random images from a trained generator
- Apply a perceptual path length filter to generated images
- Generate interpolations between two different generated images
Skills covered in this course
Reviews
-
SShukdev Datta
TILL NOW IT IS VERY EASY-GOING AND DETAILED.
-
MMalcolm Black
Excellent training for such a low price! It is less of a comprehensive course on GDNs and more of a brief overview of some well-written code that really works. I was able to successfully train a network using this code running tensorflow 2.17 with a couple updates. 1. In train.py, comment out the zero_vars(var) function. 2. In training_loop.py, remove the argument "count_mode='steps'". The course delivers on its promise for high-resolution. In fact prior to this course I was using the MNIST example from tensorflow/gan repository on GitHub. I could not get it to work for images over 112x112 pixels, and in this course Brad explained limitations such as the Wasserstein loss. It was a pleasant surprise that the main_training.py from this course simply takes a --resolution option, and the layers (ex. Conv2d) don't need to be edited to match a certain resolution. It would have been nice to include steps on how to create .tfrecords from a custom data set. (Make sure the tfrecords have features image_bytes and image_shapes.) I'm using scans of my own ink drawings, so turning PNGs into .tfrecords was a process and relevant to the course. I was making circular interpolations with the 112x112 network before taking this course, and was stoked to see a more elegant attempt despite it having little to do with GDNs. Kind of funny to see interpolation of people's faces. It shows that people's faces are good for quality benchmarking, but not transformations through a rich vector space of random images, which is just a natural application of the trained neural network. GANs should be called GDNs (Generative Discriminatory Networks), and then just add "a.k.a. GANs for [x, y, z] wrong reasons". Without a doubt I would enroll a longer, more thorough course from this instructor on StyleGAN2 or GDNs in general.
-
SSom Kumar Sahoo
Good Explanation of the topics covered.
-
AAdrian Podwysocki
Very detailed and absorbing course. The instructor is knowledgeable in the topic and the presentation is nice. I had a feeling that the lesson content was not always entirely planned - sometimes it feels like the lessons end randomly, and sometimes features mentioned in a lesson are introduced later, instead of before such mention. Other than that, the course was great and I can certainly recommend it!
