1 files changed, 43 insertions, 0 deletions
diff --git a/report/paper.md b/report/paper.md
index 77d3db7..b4a2a63 100644
--- a/report/paper.md
+++ b/report/paper.md
@@ -1,7 +1,50 @@
+# Introduction 
+
+A Generative Adversarial Network is a system in which two blocks, discriminator and generator are competing in a "minmax game",
+in which the objective of the two blocks is respectively maximization and minimization of the function presented below,
+until an equilibrium is reached. During the weights update performed through the optimization process, the generator and discrimitaor are
+updated in alternating cycles.
+
+$$ V (D,G) = E_{x~p_{data}(x)}[logD(x)] + E_{zp_z(z)}[log(1-D(G(z)))] $$
+
+The issue with shallow architectures (**present the example we used for mode collapse**) can be ontain really fast training,
+while producing overall good results.
+
+One of the main issues that raises from this kind of architectures is mode collapse. As the discriminator keeps getting 
+better, the generator tries to focus on one single class label to improve its loss. This issue can be observed in figure 
+\ref{fig:mode_collapse}, in which we can observe how after 200 thousand iterations, the output of the generator only represents few 
+of the labels originally fed to train the network. At that point the loss function of the generator starts getting worse as shown in figure
+\ref{fig:vanilla_loss}. As we observe, G-D balance in not achieved as the discriminator loss almost reaches zero, while the generator loss keeps 
+increasing.
+
+\begin{figure}
+\begin{center}
+\includegraphics[width=24em]{fig/generic_gan_loss.png}
+\caption{Shallow GAN D-G Loss}
+\label{fig:vanilla_loss}
+\end{center}
+\end{figure}
+
+\begin{figure}
+\begin{center}
+\includegraphics[width=24em]{fig/generic_gan_mode_collapse.pdf}
+\caption{Shallow GAN mode collapse}
+\label{fig:mode_collapse}
+\end{center}
+\end{figure}
+
+
 # DCGAN
 
 ## DCGAN Architecture description
 
+Insert connection of schematic.
+
+The typical structure of the generator for DCGAN consists of a sequential model in which the input is fed through a dense layer and upsampled. 
+The following block involves Convolution+Batch_normalization+Relu_activation. The output is then upsampled again and fed to another Convolution+Batch_Normalization+Relu_activation block. The final output is obtained through a Convolution+Tanh_activation layer. The depth of the convolutional layers decreases from input to output.
+
+The discriminator is designed through blocks that involve Convolution+Batch_Normalization+LeakyReLU_activation+Dropout. The depth of the convolutional layers increases from input to output. 
+
 ## Tests on MNIST
 
 Try some **different architectures, hyper-parameters**, and, if necessary, the aspects of **virtual batch