Architectures

Autoencoder 1
CNN 1
GAN 2
MLP 2
RNN 3
VAE 4

Autoencoder
TODO: Description of Autoencoder use case and basic architecture. Figure from [1].

Model
An example implementation in PyTorch.
Training
Further reading

• Convolutional Autoencoders
• Deep Learning Book

CNN
TODO: Description of CNN use case and basic architecture. Figure from [2].
 Model
An example implementation in PyTorch.
Training
Further reading

• CS231 Convolutional Networks

• Deep Learning Book

GAN
A Generative Adversarial Network (GAN) is a type of network which creates novel tensors (often images,
voices, etc.). The generative portion of the architecture competes with the discriminator part of the
architecture in a zero-sum game. The goal of the generative network is to create novel tensors which the
adversarial network attempts to classify as real or fake. The goal of the generative network is generate
tensors where the discriminator network determines that the tensor has a 50% chance of being fake and a
50% chance of being real.
Figure from [3].

Model
An example implementation in PyTorch.
Generator
Discriminator
Training
Further reading

• Generative Adversarial Networks

• Deep Learning Book
• PyTorch DCGAN Example
• Original Paper

MLP
A Multi Layer Perceptron (MLP) is a neural network with only fully connected layers. Figure from [5].
 Model
An example implementation on FMNIST dataset in PyTorch. Full Code

1. The input to the network is a vector of size 28*28 i.e.(image from FashionMNIST dataset of
dimension 28*28 pixels flattened to sigle dimension vector).
2. 2 fully connected hidden layers.
3. Output layer with 10 outputs.(10 classes)
Training
Evaluating
Further reading
TODO

RNN
Description of RNN use case and basic architecture.

Model
Training
In this example, our input is a list of last names, where each name is a variable length array of one-hot
encoded characters. Our target is is a list of indices representing the class (language) of the name.

1. For each input name..

2. Initialize the hidden vector
3. Loop through the characters and predict the class
 4. Pass the final character's prediction to the loss function
5. Backprop and update the weights
Further reading

• Jupyter notebook
• Deep Learning Book

VAE
Autoencoders can encode an input image to a latent vector and decode it, but they can't generate novel
images. Variational Autoencoders (VAE) solve this problem by adding a constraint: the latent vector
representation should model a unit gaussian distribution. The Encoder returns the mean and variance of
the learned gaussian. To generate a new image, we pass a new mean and variance to the Decoder. In
other words, we "sample a latent vector" from the gaussian and pass it to the Decoder. It also improves
network generalization and avoids memorization. Figure from [4].

Loss Function
The VAE loss function combines reconstruction loss (e.g. Cross Entropy, MSE) with KL divergence.
Model
An example implementation in PyTorch of a Convolutional Variational Autoencoder.
Training
Further reading

• Original Paper
• VAE Explained
• Deep Learning Book
References

1 https://hackernoon.com/autoencoders-deep-learning-bits-1-11731e200694
2 http://cs231n.github.io/convolutional-networks
3 http://guertl.me/post/162759264070/generative-adversarial-networks
4 http://kvfrans.com/variational-autoencoders-explained