60 Advanced Deep Learning Interview Questions (ANSWERED) To Crush Your ML Interview

• Artificial neural networks are modelled from biological neurons.
• The connections of the biological neuron are modeled as weights.
  • A positive weight reflects an excitatory connection, while negative values mean inhibitory connections.
  • All inputs are modified by a weight and summed. This activity is referred to as a linear combination.
• Finally, an activation function controls the amplitude of the output. For example, an acceptable range of output is usually between 0 and 1, or it could be −1 and 1.

• Ensemble methods are used to increase the generalization power of a model. These methods are applicable to both deep learning as well as machine learning algorithms.
• Some ensemble methods introduced in neural networks are Dropout and Dropconnect. The improvement in the model depends on the type of data and the nature of neural architecture.

• Machine Learning depends on humans to learn. Humans determine the hierarchy of features to determine the difference between the data input. It usually requires more structured data to learn.
• Deep Learning automates much of the feature extraction piece of the process. It eliminates the manual human intervention required.
• Machine Learning is less dependent on the amount of data as compared to deep learning.
• Deep Learning requires a lot of data to give high accuracy. It would take thousands or millions of data points which are trained for days or weeks to give an acceptable accurate model.

• Neural Networks are used in unsupervised learning to learn better representations of the input data.
• Neural networks can learn a mapping from document to real-valued vector in such a way that resulting vectors are similar for documents with similar content. This can be achieved using autoencoders which is a model that is trained to reconstruct the original vector from a smaller representation with reconstruction error as a cost function.
• There are neural networks that are specifically designed for clustering as well. The most widely known is the self-organizing maps (SOM).

• The neural networks get the optimal weights and bias values through an Error Gradient.
• To decide whether to increase or decrease the current weights and bias, it needs to be compared to the optimal value. This is found by the gradients of error with respect to weights and bias:

• The gradient value is calculated from a selected algorithm called backpropagation.
• An optimization algorithm utilizes the gradient to improve the weight values and bias.

• Incremental learning refers to the ability of an algorithm to learn from new data that may become available after a classifier has already been generated from a previously available dataset.
• An algorithm is said to be an incremental learning algorithm if, for a sequence of training datasets, it produces a sequence of hypotheses where the current hypothesis describes all data that have been seen thus far but depends only on previous hypotheses and the current training data.
• Ensemble-based systems can be used for such problems by training an additional classifier (or an additional ensemble of classifiers) on each dataset that becomes available.

There are some subtle signs that you may be suffering from exploding gradients during the training of your network, such as:

• The model is unable to get traction on your training data (e g. poor loss).
• The model is unstable, resulting in large changes in loss from update to update.
• The model loss goes to NaN during training.

If you have these types of problems, you can dig deeper to see if you have a problem with exploding gradients. There are some less subtle signs that you can use to confirm that you have exploding gradients:

• The model weights quickly become very large during training.
• The model weights go to NaN values during training.
• The error gradient values are consistently above 1.0 for each node and layer during training.

• The model will improve very slowly during the training phase and it is also possible that training stops very early, meaning that any further training does not improve the model.
• The weights closer to the output layer of the model would witness more of a change whereas the layers that occur closer to the input layer would not change much (if at all).
• Model weights shrink exponentially and become very small when training the model.
• The model weights become 0 in the training phase.

• If the output to be predicted is real, then it makes sense to use a Linear Activation function.
• If the output to be predicted is a probability of a binary class, then a Sigmoid function should be used.
• If the output to be predicted has two classes, then a Tanh function can be used.
• ReLU function can be used in many different cases due to its computational simplicity.

• Neural network requires a loss function to be chosen when designing and configuring the model.
• While optimizing the model, an objective function is either a loss function or its negative. The objective function is sought to be maximized or minimized (output which has the highest or lowest score respectively). Typically, in a neural network the error should be minimized.
• The loss function should reduce all the aspects of a complex model down to a single scalar value, which allows the candidate solutions to be ranked and compared.
• The loss function chosen by the designer should capture the properties of the problem and be motivated by concerns that are important to the project.

• Activation Functions help in keeping the value of the output from the neuron restricted to a certain limit as per the requirement. If the limit is not set then the output will reach very high magnitudes. Most activation functions convert the output to -1 to 1 or to 0 to 1.
• The most important role of the activation function is the ability to add non-linearity to the neural network. Most of the models in real-life is non-linear so the activation functions help to create a non-linear model.
• The activation function is responsible for deciding whether a neuron should be activated or not.

• An activation function applies a step rule (convert the numerical output into +1 or -1) to check if the output of the weighting function is greater than zero or not.
• An activation function of a node defines the output of the node given an input or set of inputs to the node.

• Activation functions can be divided into three categories:
  • Ridge functions
  • Radial functions, and
  • Fold functions.

• A type of ridge function called Rectified Linear Function (ReLU) is shown below:

• A type of radial function called Gaussian Function is shown below:

• A fold function perform an aggregation over the inputs, such as taking the mean, minimum or maximum.

Convolutional neural nets apply a convolution to the data before using it in fully connected layers.

• They are best used in cases where you want positional invariance, that is to say, you want features to be captured regardless of where they are in the input sample.

• Think of a picture with all sorts of animals in it. If you apply a convolutional neural net to classify whether there is a cat in the picture, it will identify the cat no matter what position in the picture the cat is (at the top, the bottom, left or right). This is very useful for image classification.

Recurrent neural nets are neural networks that keep state between input samples. They remember previous input samples and use those to help classify the current input sample.

• They are most useful when the order of your data is important. So for instance in speech (previous words do help identify the current word), video (frames are ordered) and also text processing.

• Generally speaking, problems related to time-series data (data with a timestamp on them) are good candidates to be solved well with recurrent neural nets.

• One of the best benefits of Deep Learning is its ability to perform automatic feature extraction from raw data.
• When the number of data fed into the learning algorithm increases, there will be more edge cases taken into consideration and hence the algorithm will learn to make the right decisions in those edge cases.

Batch Normalization (BN) focuses on standardizing the inputs to any particular layer (i.e. activations from previous layers). Standardizing the inputs mean that inputs to any layer in the network should have approximately zero mean and unit variance, but each layer doesn’t need to expect inputs with zero mean and unit variance, instead, probably the model might perform better with some other mean and variance. Hence the BN layer also introduces two learnable parameters γ and β.

In this process, BN calculates the mini-batch mean and variance) in every training iteration, therefore it requires larger batch sizes while training so that it can effectively approximate the population mean and variance from the mini-batch. This makes BN harder to train networks for applications such as object detection, semantic segmentation, etc because they generally work with high input resolution (often as big as 1024 x 2048) and training with larger batch sizes is not computationally feasible. Moreover, during test (or inference) time, the BN layer doesn’t calculate the mean and variance from the test data mini-batch but uses the fixed mean and variance calculated from the training data. This requires caution while using BN and introduces additional complexity.

Yes, The encoding component of the autoencoder can be used to generate new features for a model to take in and process when performing a task. Because the encoder has learned to take in a standard input and compress it such that each feature in the encoded representation contains the most important information from the standard input, these encoded features can be exploited to create features and aid the prediction of another model.

The purpose of feature generation is to generate, or add features rather than replace them. Thus, when using autoencoders for feature generation, the encoder provides one set of encoded, information-rich features that are considered alongside the original set of features.

To use autoencoders for feature generation, the encoder's output is concatenated (or merged through some other mechanism) with the original input data, such that the remainder of the network can consider and process both sets of features.

However, if the autoencoder itself does not obtain a relatively high performance in reconstruction (i.e., middling, mediocre performance), forcing the new network model only to take in mediocre-level features could limit its performance. Alternatively, if the data is not of extremely high complexity, like tabular data or lower-resolution images, having an encoder compress the original inputs may be valuable, but not completely necessary. In many cases, models intended for less complex data benefit from processing both the original input and encoded features.

• In a typical CNN architecture, a few convolutional layers are connected in a cascade style.
• Each convolutional layer is followed by a Rectified Linear Unit (ReLU) layer, then a pooling layer, then one or more convolutional layers (+ReLU), then another pooling layer.
• The output from each convolution layer is a set of objects called feature maps, generated by a single kernel filter.
• The feature maps are used to define a new input to the next layer.
• At the end, there is one or more fully connected layers.
• Pretty much depending on problem type, the network might be deep though.

• In a single layer Neural Network, a set of inputs are directly mapped to an output by using a generalized variation of a linear function. This is called a perceptron.

• A perceptron may be designed to give a binary class output. Historical cases for which the class variable is observed, and other cases in which the class variable has not been observed needs to be predicted.

The initialization step can be critical to the model's performance, and it requires the right method.

• Initializing the weights to zero leads the network to learn zero output which makes the network not learn anything.
• Initializing the weights to be too large causes the network to experience exploding gradients.
• Initializing the weights to be too small causes the network to experience vanishing gradients.

To find the perfect initialization, there are a few rules of thumb to follow:

• The mean of activations should be zero.
• The variance of activations should stay the same across every layer.

If you have a CNN with some dense layers on top, you can convert these dense layers to convolutional layers to create an FCN in the following way:

• Replace the lowest dense layer with a convolutional layer with a kernel size equal to the layer's input size, with one filter per neuron in the dense layer, and use valid padding.
• Generally, the stride should be 1, but you can set it to a higher value if you want.
• The activation function should be the same as the dense layer's.
• The other dense layers should be converted the same way, but using 1 × 1 filters.
• It is actually possible to convert a trained CNN this way by appropriately reshaping the dense layers' weight matrices.

• The random dropping of connections between different layers in a multilayer neural network often leads to diverse models in which different combinations of features are used to construct the hidden variables.
• The dropping of connections between layers creates less powerful models because of the addition of constraints to the model-building process. However, since different random connections are dropped from different models, the predictions from different models are very diverse.

An RNN layer must have three-dimensional inputs:

• The first dimension is the batch dimension (its size is the batch size.
• The second dimension represents the time (its size is the number of time steps),
• And the third dimension holds the inputs at each time step (its size is the number of input features per time step).

For example, if you want to process a batch containing 5 time series of 10 time steps each, with 2 values per time step (e.g., the temperature and the wind speed), the shape will be [5, 10, 2].

The outputs are also three-dimensional, with the same first two dimensions, but the last dimension is equal to the number of neurons. For example, if an RNN layer with 32 neurons processes the batch we just discussed, the output will have a shape of [5, 10, 32].

• A very strong correlation between the new feature and an existing feature is a fairly good sign that the new feature provides little new information.

• A low correlation between the new feature and existing features is likely preferable.

• A strong linear correlation between the new feature and the predicted variable is a good sign that a new feature will be valuable, but the absence of a high correlation is not necessarily a sign of a poor feature, because neural networks are not restricted to linear combinations of variables.

• If the new feature was manually constructed from a combination of existing features, consider leaving it out. The beauty of neural networks is that little feature engineering and preprocessing are required - features are instead learned by intermediate layers.

• Whenever possible, prefer learning features to engineering them.

A neural network designed for a regression problem can easily be changed to classification.

It requires two changes to the code:

1. A change to the output layer.
2. A change to the loss function.

A neural network designed for regression will likely have an output layer with one node to output one value and a linear activation function, for example, in Keras this would be:

...
model.add(Dense(1, activation='linear'))

We can change this to a binary classification problem (two classes) by changing the activation to sigmoid, for example:

...
model.add(Dense(1, activation='sigmoid'))

We can change this to a multi-class classification problem (more than two classes) by changing the number of nodes in the layer to the number of classes (e.g. 3 in this example) and the activation function to softmax, for example:

model.add(Dense(3, activation='softmax'))

Finally, the model will have an error based loss function, such as 'MSE' or 'MAE', for example:

...
# compile model
model.compile(loss='mse', optimizer='adam')

We must change the loss function for a binary classification problem (two classes) to binary_crossentropy, for example:

...
# compile model
model.compile(loss='binary_crossentropy', optimizer='adam')

We must change the loss function for a multi-class classification problem (more than two classes) to categorical_crossentropy, for example:

...
# compile model
model.compile(loss='categorical_crossentropy', optimizer='adam')

That is it. Ultimately, it's recommended to re-tuning the hyperparameters of the neural network for your specific predictive modeling problem.

• Binary targets: In this case, the observed value is drawn from -1 to 1. The loss function for this case is shown as follows:

  $L = log(1 + exp(-y.\hat y))$

  Where, $\hat y$ is the predicted output. y is the observed output.

  This type of loss function implements a machine learning method known as logistic regression.

• Categorical targets: If y are the probabilities of k classes, and rth class is the ground truth class, the loss function for a single instance is defined as follows:

  $L = -log(\hat y_r)$

  This type of loss function implements multinomial logistic regression, and it is called cross-entropy loss.

• Binary logistic regression is similar to multinomial logistic regression with the value of k set to 2.

Hyperparameters are the variables which determine the network structure and the variables that determine how the network is trained. Some hyperparameters which can be tuned in the neural network include:

• Number of hidden layers: Less number of hidden layers may cause underfitting. Increasing the number of hidden layers will improve accuracy.
• Dropout: It is a regularization technique to avoid overfitting (increasing the validation accuracy). If the neural network is large then using dropout will cause the network to learn independent representations well.
• Network Weight Initialization: Initializing the weights according to the activation function used will give better performance.
• Activation function: Activation functions give nonlinearity to the neural network. The activation function is chosen according to the prediction made such as using sigmoid for binary predictions and softmax for multi-class predictions.

If for 1D signal you mean time-series data, where you assume temporal dependence between the values, then convolutional neural networks (CNN) are one of the possible approaches. The most popular neural network approach to such data is to use recurrent neural networks (RNN), but you can alternatively use CNNs, or a hybrid approach (quasi-recurrent neural networks, QRNN).

With RNN, you would use a cell that takes as input previous hidden state and current input value, to return output and another hidden state, so the information flows via the hidden states.

With CNN, you would use sliding window of some width, that would look at certain (learned) patterns in the data, and stack such windows on top of each other, so that higher-level windows would look for patterns within the lower-level patterns. Using such sliding windows may be helpful for finding things such as repeating patterns within the data (e.g. seasonal patterns). QRNN layers mix both approaches.

• The ResNet architectures: or residual neural networks, uses residual connections, or skip connections, which are connections between layers that skip over at least one intermediate layer. ResNet comes in two versions: ResNetV1 and ResNetV2: ResNetV1 passes the data through a convolutional layer before batch normalization and an activation layer, whereas ResNetV2 passes data through the batch normalization and activation layers before the convolutional layer (reversed).

• InceptionV3: uses a module/cell-based structure in which certain sets of layers are repeated. Inception networks are more computationally efficient by reducing the number of parameters necessary and limiting the memory and resources needed to be consumed. This architecture was designed primarily with a focus on minimizing computational cost, whereas ResNet focuses on maximizing accuracy.

• MobileNet: designed to perform well on mobile phone deep learning applications, uses depth-wise separable convolutions, which are convolutions that apply not only spatially but also depth-wise. MobileNet has more parameters than Inception but less than ResNet; correspondingly, MobileNet has been generally observed to perform worse than ResNet but better than Inception.

• A Generative Adversarial Network (GAN) is a type of neural network architecture for generative modeling.
• GAN has the capability to generate examples for image datasets, photographs, characters, etc.
• Generative adversarial networks are a model of data generation that can create a generative model of a base data set by using an adversarial game between two players. The two players correspond to a generator and a discriminator.
• The generator takes Gaussian noise as input and produces an output, which is a generated sample like the base data.
• The discriminator is a probabilistic classifier like logistic regression whose job is to distinguish real samples from the base dataset and the generated sample.

• A multilayer perceptron is a type of neural network which has many layers of perceptron stacked on top of each other.
• Mathematically, multilayer perceptron are capable of learning any mapping function and have been proven to be a universal approximation algorithm.
• Single layer perceptron only learn linear patterns, while multilayer perceptron can learn complex relationships. This predictive capability comes from the multi-layered structure of the network, so that the features can be combined into higher-order features.

• Neural networks require too much data to train. A classification network may require thousands of examples in a single class for it to identify it in unseen data. Due to this, sometimes it is not feasible to create ANN models for fringe applications.
• Neural networks are not interpretable. The user needs to input data into the network and it outputs the required output, but the work that goes into processing the input and giving an output is not understandable to human beings.
• The power required to train the neural network is extremely high compared to the amount of power that a human brain uses (around 20 Watts) to do almost the same things such as image classification.

• SVM has a number of parameters that increases linearly with the linear increase in the size of the input. All the parameters of the SVM interacts with one another.

• Neural Networks have as many layers as possible, but due to the complex interaction between the model's parameters, NN always has a higher complexity when compared with SVM with a similar number of parameters.

• SVMs use only a subset of data for training. They can reliably define the decision boundary solely on the basis of the support vectors. As a result, they do not require much data for training.

• Neural Networks get trained based on the batches of data fed into it. This means that the specific decision boundary that the neural network learns is highly dependent on the order in which the batches of data are presented to it. This, in turn, requires processing the whole training dataset; or otherwise, the network may perform extremely poorly.

A 1x1 convolution simply maps an input pixel with all its channels to an output pixel, not looking at anything around itself. It is often used to reduce the number of depth channels since it is often very slow to multiply volumes with extremely large depths.

input (256 depth) -> 1x1 convolution (64 depth) -> 4x4 convolution (256 depth)

input (256 depth) -> 4x4 convolution (256 depth)

The bottom one is about ~3.7x slower.

Theoretically, the neural network can choose which input colors to look at using this, instead of brute force-multiplying everything.

• Networks with more layers (Depth) tend to require fewer units per layer because the composition functions created by successive layers make the neural network more powerful.
• The number of units in each layer of a deep network can be decreased to such an extent that when compared to a shallower network (more Breadth), the deep network has far fewer parameters even when added up over the greater number of layers.
• In neural networks with many layers the loss derivatives with respect to the weights in different layers of the network tend to have vastly different magnitudes, which causes challenges in properly choosing step sizes. This can lead to vanishing and exploding gradient problems.

• Early stopping in deep learning is a type of regularization where the training is stopped after a few iterations.
• When training a large network, there will be a point during training when the model will stop generalizing and start learning the statistical noise in the training dataset. This makes the networks unable to predict new data.
• Defining early stopping in a neural network will prevent the network from overfitting.
• One way of defining early stopping is to start training the model and if the performance of the model starts to degrade, then stopping the training process.

• Exploding gradient problem is a problem in a neural network where a large error gradient accumulates which results in very large updates to the neural network model weights during training.
• This causes the neural network to stop learning.
• In deep multilayer perceptron networks, this problem creates an unstable network that can not learn from the training data, or at its worst, it creates a NaN weight value that can not be updated.
• In recurrent neural networks, this problem causes the network to be unable to learn from long input sequences of data.

• The vanishing gradient problem is encountered in artificial neural networks with gradient-based learning methods and backpropagation.
• In these learning methods, each of the neural networks weights receives an update proportional to the partial derivative of the error function with respect to the current weight in each iteration of training. Sometimes when gradients become vanishingly small, this prevents the weight to change value.
• If the neural network has many hidden layers, the gradients in the earlier layers will become very low as we multiply the derivatives of each layer. As a result, learning in the earlier layers becomes very slow.
• This can cause the neural network to stop learning.
• This problem of vanishing gradient descent happens when training neural networks with many layers because the gradient diminishes dramatically as it propagates backwards through the network.

• Many fixes and workarounds have been proposed and investigated to fix the vanishing gradient problem, such as

  • alternate weight initialization schemes,
  • unsupervised pre-training,
  • layer-wise training, and
  • variations on gradient descent.

  Perhaps the most common change is the use of the rectified linear activation function that has become the new default, instead of the hyperbolic tangent activation function that was the default through the late 1990s and 2000s.

• A Linear Activation function is represented by the following equation:
  $A = cx$
• A linear activation function takes the inputs, multiplied by weights for each neuron, and creates an output signal proportional to the input.
• A Non-linear Activation function uses non-linear activation functions. They create complex mappings between the networks inputs and outputs. It is important to create complex mappings because images, audio, and video are non-linear or have high dimensionality.

• Neural networks with only linear activation does not gain from increasing the number of layers in it due to the fact that all linear functions add up to a single linear function. So, if there are many layers in a network with only linear activation functions, it is as though there is only one layer.
• Non-linear activation functions allow the stacking of different layers and it will not be treated as a single layer as in the linear activation layer.

• The derivation of a linear function is a constant (it has no relation to the input), so it is not possible to use backpropagation when it comes to linear functions.
• Non-linear functions allow backpropagation due to the fact that they can be differentiated, and their derivative is related to the input.

• Reinforcement learning is a type of machine learning paradigm where the model take action to maximize the notion of cumulative reward much like living beings do.
• Learning how to play games, and self-driving cars are all modeled as a reinforcement learning problem.
• If the problem to be modeled is a game, then the screen is taken as input. The algorithm takes the pixels as input and passes it through multiple layers of convolutional neural networks to give an output for the next steps to take. The outcome of the steps taken by the model serves as the positive or negative reinforcement.

There are different types of recurrent neural networks with varying architectures. Some examples are:

• One to one: Here there is a single (xt,yt) pair. Traditional neural networks employ a one to one architecture.

• One to many: In one to many networks, a single input at xt can produce multiple outputs, e.g., yt0, yt1, yt2 Music generation is an example area, where one to many networks are employed.

• Many to one: In this case, many inputs from different time steps produce a single output. For example, xt, xt+1, xt+2 can produce a single output. Such networks are employed in sentiment analysis or emotion detection, where the class label depends upon a sequence of words.

• Many to many: There are many possibilities for many to many. An example is shown below, where two inputs produce three outputs. Many to many networks are applied in machine translation, e.g, English to French or vice versa translation systems.

Let us establish some notations: we will assume that the activations at any layer would be of the dimensions NxCxHxW, where:

• N = Batch Size,
• C = Number of Channels (filters) in that layer,
• H = Height of each activation map,
• W = Width of each activation map.

Generally, normalization of activations requires shifting and scaling the activations by mean (μ) and standard deviation (σ) respectively. Batch Normalization, Instance Normalization and Layer Normalization differ in the manner these statistics are calculated.

• In Batch normalization, mean and variance are calculated for each individual channel across all samples and both spatial dimensions H and W.

• In Instance normalization, mean and variance are calculated for each individual channel for each individual sample across both spatial dimensions H and W.

• In Layer normalization, mean and variance are calculated for each individual sample across all channels and both spatial dimensions H and W.

• The job of an autoencoder is to simultaneously learn an encoding network and decoding network. This means an input (e.g. an image) is given to the encoder, which attempts to reduce the input to a strongly compressed encoded form, which is then fed to the decoder.

  The network learns this encoding/decoding because the loss metric increases with the difference between the input and output image -every iteration, the encoder gets a little bit better at finding an efficient compressed form of the input information, and the decoder gets a little bit better at reconstructing the input from the encoded form.

  To summarize, an autoencoder learns to represent some input information very efficiently, and subsequently how to reconstruct the input from its compressed form.

• In Generative Adversarial Networks, we have a "generator" whose job is to take some noise signal and transform it to some target space (again, images are a popular example). The other component (the adversary) is the "discriminator", whose job is to distinguish real images drawn from the desired target space from the fake images created by the generator. In this case, the network is trained in two alternating phases, each with a different loss.

  In short, A GAN uses an adversarial feedback loop to learn how to generate some information that "seems real" (i.e. looks the same/sounds the same/is otherwise indistinguishable from some real data).

• Recurrent Neural Networks:

  • It is used for sequential inputs where the time factor is the main differentiating factor between the elements of the sequence, that's why it's commonly used in time-series.
  • When we unfold the network, at each time step, it accepts the user input at that time step and the output of the hidden layer that was computed at the previous time step.
  • The weights are shared (and dimensionality remains constant) along the length of the sequence.

• Recursive Neural Networks:

  • Is more like a hierarchical network where there is really no time aspect to the input sequence but the input has to be processed hierarchically in a tree fashion.
  • Is very used in NLP, where the way to learn a parse tree of a sentence is recursively taking the output of the operation performed on a smaller chunk of the text.
  • Here, the weights are shared (and dimensionality remains constant) at every node.

• An autoencoder consists of two parts, an encoder, and a decoder. The encoder compresses the data from a higher-dimensional space to a lower-dimensional space (also called the latent space), while the decoder does the opposite i.e., convert the latent space back to higher-dimensional space. One drawback of this latent space is that is not regularized: there may be parts of the latent space that doesn't correspond to any data point from the original data so we say that the latent space lacks the generative capability. Once the network is trained, and the training data is removed, we have no way of knowing if the output generated by the decoder from a randomly sampled latent vector is valid or not.
• The two main uses of an autoencoder are to compress data to two (or three) dimensions so it can be graphed and to compress and decompress images or documents, which removes noise in the data.

• A variational encoder addresses the issue of non-regularized latent space by imposing a constraint on this latent space: forces it to be a normal distribution. So instead of outputting the vectors in the latent space, the encoder of VAE outputs the mean and the standard deviation for each latent variable. The latent vector is then sampled from this mean and standard deviation which is then fed to the decoder to reconstruct the input.
• The one main use of a variational autoencoder is to generate new data that is related to the original source data. Now exactly what the additional data is good for is hard to say. A variational autoencoder is a generative system and serves a similar purpose as a generative adversarial network