Feedforward neural networks are called networks because they are typically represented by composing together many different functions. The model is associated with a directed acyclic graph describing how the functions are composed together.

For example, we might have three functions $f^{(1)} , f ^{(2)}$, and $f^{(3)}$ connected in a chain, to form $f (x) = f ^{(3)}(f^{(2)}(f^{(1)}(x)))$. These chain structures are the most commonly used structures of neural networks. 


Overall Structure of Deep Feedforward Networks

A Feed forward neural network model training occurs in six stages:

- Iterate until convergence
   - Initialization
   - Forward propagation
   - Error function (Objective function)
   - Backpropagation
   - Weight update

At the end of this process, the model is ready to make predictions for unknown input data. New data can be fed to the model, a forward pass is performed, and the model generates its prediction.

Stages of Feed Forward Neural Network Learning

A hyperparameter is a setting that affects the structure or operation of the neural network. In real deep learning projects, tuning hyperparameters is the primary way to build a network that provides accurate predictions for a certain problem. 

Hyperparameters of Feedforward Neural Network

There are a few different types of cost functions, but for the most part the same type of cost function is used for neural networks. We usually use the principle of maximum likelihood for most cases, such as when our parametric model uses a distribution p(y | x;θ), where the relationship between the input (training data) and output (model's predictions) of the model as the cost function. A sometimes simpler approach used, where we are predicting some statistic of y conditioned on x, instead of predicting a complete probability distribution over y. 

Deep Feedforward Network Cost Functions

-The chain rule that underlies the back-propagation algorithm (one of the common algorithms used to train neural networks) was invented in the seventeenth century.

-While algebra and advanced mathematics have always been implemented to solve computer optimization problems, gradient descent was not introduced as a technique for iteratively approximating the solution to optimization problems until the nineteenth century.

-Non-linear functions could only be properly studied once a multilayer perceptron and a means of computing the gradient were developed. One of the biggest advancements for this development occurred once eﬃcient applications of the chain rule based on dynamic programming were implemented between the 1960s and 70s. 


Deep Feedfoward Network as time passed.

Approaches to back-propagation taking a computational graph and a set ofnumerical values for the inputs to the graph and returning a set of numerical valuesdescribing the gradient at those input values is called symbol-to-number diﬀerentiation.

Symbol-to-number Diﬀerentiation

Theano and Tensorflow Approach is to take a computational graph and add additional nodes to the graph that provide a symbolic description of the desired derivatives.

Theano and Tensorflow Approach

These algebraic and graph-based representations operating on symbols, orvariables that do not have speciﬁc values are called symbolic representations.

Symbolic Representations

Language modeling is one of the application of feedforward networks: predicting upcoming words from prior word context. Neural language modeling
is an important NLP task in itself, and it plays a role in many important algorithms for tasks like machine translation, summarization, speech recognition, grammar correction, and dialogue.



Feedforward Neural Language Modeling

Most Neural NLP classifications take word embeddings as their inputs.
$$ x = [e_{w1};e_{w2};e_{w3};...;e_{wn}]$$
These kind of embeddings are gained from the pertaining process relying on another algorithm.
Embedding can also be learned as part of the NLP task in the neural language modeling task.



Feedforward Neural Network Classification in NLP

Deep feedforward networks, also called feedforward neural networks, or multilayer perceptrons (MLPs), are the quintessential deep learning models.

It was the first and simplest type of artificial neural network devised. In this network, the information moves in only one direction, forward, from the input nodes, through the hidden nodes (if any) and to the output nodes. There are no cycles or loops in the network.

University of Michigan - Ann Arbor

Deep learning algorithms can be implemented to solve real-world problems today.

Deep feedforward networks, also called multilayer perceptrons (MLPs), is the quintessential deep learning model that is behind nearly all modern practical applications of deep learning.

Scaling these models to large inputs such as high-resolution images or long temporal sequences requires specialization. 
 - Convolutional neural networks (CNN) can be used for processing large images.
 - Recurrent neural networks (RNN) can be used for processing temporal sequences. 


Deep Learning Algorithms

Goodfellow, I., Bengio, Y., & Courville, A. (2016). $\mathit{Deep \ Learning.}$ MIT Press. Retrieved from [www.deeplearningbook.org](https://www.deeplearningbook.org) 

Deep Learning

Wikipedia

Recent Developments on Statistical and Neural Network Tools Focusing on Biodiesel Quality - Scientific Figure on ResearchGate. Available from: https://www.researchgate.net/figure/TOPOLOGY-OF-A-MULTILAYER-PERCEPTRON-NEURAL-NETWORK_fig1_274240858 [accessed 12 Feb, 2021]

Topology of a multilayer perceptron neural network

A helpful website that introduces neural networks:
https://missinglink.ai/guides/neural-network-concepts/

Neural Network Reference

Convolutional networks, also known as convolutional neural networks, or CNNs, are a specialized kind of neural network for processing data that has a known grid-like topology. Examples include time-series data, which can be thought of as a 1-D grid taking samples at regular time intervals, and image data, which can be thought of as a 2-D grid of pixels. 

The network employs a mathematical operation called convolution. Convolution is a specialized kind of linear operation. Convolutional networks are simply neural networks that use convolution in place of general matrix multiplication in at least one of their layers.

The CNN gets its power from the following concepts:
- Sparse connectivity
- Parameter sharing

Convolutional Neural Network (CNN)

Recurrent neural networks, or RNNs, are a family of neural networks for processing sequential data. A recurrent neural network is specialized for processing a sequence of inputs $x^{(1)}, . . . , x^{(τ)}$ and each time add additional layers of comprehension on top of the previous inputs. 


Recurrent Neural Network (RNN)

**Generative Models**  As might be clear from their name , generative models are able to generate new contents by learning features of certain datasets. As for more formal definition, generative models specify in terms of a probabilistic model describing how it thinks the dataset was produced.  Using sampling from this probability distribution, we can create new data in the style of the old.
 
The joint probability distribution P(X,Y) is learned from the data, and then divided by P(X) to obtain the conditional probability distribution P(Y|X), which is used as a predictive model. It is called a generative model because the model represents the relationship between a given input X and an output Y. Common generative models are: Naive Bayes, Hidden Markov Model, Gaussian Mixture Model, Document Topic Generation Model (LDA), and restricted Boltzmann machine.

Generative Models

There are functions you can compute with a small layer that shallower networks would need a lot more hidden units in order to compute. 

Circuit Theory

https://www.simplilearn.com/deep-learning-algorithms-article

More about deep learning algorithms 

Data inputted into deep learning algorithms should be split into a distribution in which the majority of data (well over 70%+) is fed into the training set. This differs from traditional machine learning algorithms which had ~70% of the data given to the training set. This difference comes from the fact that there is now much more data available and deep learning algorithms improve with more data, whereas traditional machine learning algorithms improvement levels out after a certain amount of data is fed in.

For example, in a dataset of 1 million examples, you mighht decide that 10k examples are enough to evaluate which algorithm is better - 98% train, 1% dev, 1% test.

Deep learning train/dev/test split 

Deep Feedforward Networks (MLP = Multi-Layer Perceptrons)

Instead of manually building up deep network architectures, many python libraries are available online to help users to easily implement deep learning models.

- Trax (built on TensorFlow)
- Tensor2Tensor (built on TensorFlow)
- Pytorch
- Fast.ai ( built on top of PyTorch)
- Keras (built to be a higher level framework to interface with other frameworks like TensorFlow)
- Vowpal Wabbit 
- Theano
- Caffee 

Deep Learning Python libraries (frameworks)

What can convolutional neural networks be used for?

A generative adversarial network (GAN) is a class of machine learning framework where two neural networks, a generative model and a discriminant model, contest against each other in a "game" (in the form of a zero-sum game, where one agent's gain is another agent's loss). Given a training set, this technique learns to generate new data with the same statistics as the training set. 

The core idea of a GAN is based on the "indirect" training through the discriminator, which itself is also being updated dynamically. This basically means that the generator is not trained to minimize the distance to a specific image, but rather to fool the discriminator and the discriminator is rewarded every time it correctly deduces if a sample is from the model distribution or the data distribution. This enables the model to learn in an unsupervised manner.

Deep Learning Frameworks

Adversarial examples arise under particular circumstances within a dataset.

An adversarial example is loosely defined as an input value for which small changes dramatically alter the classification output of the given model, however, to a human observer, little change in the input is detected. 

An example of an "adversarial example" from the Deep Learning book has been provided below. This example is adversarial because there is no apparent change between the first and second panda photos (none at least, detectable by the author of this node), however, the model in question classified the first photo as a panda, but the second a gibbon - a species of ape that do not resemble pandas.



Adversarial Examples

Deep Learning models require incredible computational resources to successfully train a model. As a result, optimizing the training process is a key step in developing an algorithm. One approach involves finding the parameters of a neural network that minimize its loss function. This is accomplished via gradient descent, a popular technique for minimizing loss function error. 

Optimization for Training Deep Models

Whereas deep learning algorithms were once always implemented on a single computer's central processing unit (CPU), research has shown that families of CPUs or even a single graphics processing unit (GPU) is much more effective. Some systems employ even greater parallelization to achieve the fastest training times with distributed architectures.

Implementations of Deep Learning

Monte Carlo algorithms return results with variability. The variability can typically be reduced by allocating more resources. The benefit of Monte Carlo algorithms is that they can provide an approximated estimation with limited source while maintaining a certain degree of accuracy. In Machine Learning, many problems are too complicated to have precise answers. Monte Carlo approximations are therefore a good approach to these problems.

Learn Before

Related

Learn After