// Other

How to Train a Neural Network with Data

// Other

How to Train a Neural Network with Data

Although Artificial Intelligence has been around since the 1950s, it became famous in the recent past. The main reason for this rise was the revival of deep learning or in other words deep neural networks. Neural networks have been around *for more than 50 years now* but, their use was not very common due to their computational cost. However, as the computer hardware started to improve **neural networks started becoming a reality**.

Everyone started taking the interest in using the neural networks for all sorts of tasks like **speech recognition** and **image classification**. Things finally come to a head in 2012 on the Large Scale Visual Recognition Challenge(LSVRC). In 2010, a large database known as Imagenet containing millions of labeled images was created and published by Fei-Fei Li’s group at Stanford.

This database was coupled with the **annual LSVRC**, in this competition, the contests build their own models, make them predict on the test data and get ranked for their accuracy. So, along with all other discoveries like new non-linearity introducing functions, *fast computing with help of GPUs*, new kind of optimizers and improved architectures of neural networks, data also played a key role in *fueling neural networks*. As use cases cover all fields including AI in sales and marketing.

In a typical neural network, these **neurons are stacked vertically** to form a layer and then these layers are stacked horizontally to form a multilayer neural network. The first layer of a neural network is usually the **input layer**, the last layer is called the **output layer** and the middle layers are called **hidden layers**. You may be impressed but neural networks are widely used in ICO and even some counterparts suggest to use them in cryptocurrency exchange software.

The number of neurons in the first layer equals the number of input variables (features), the number of neurons in the middle layers are **hyperparameters** (that you decide for optimization) and the number of neurons in the last layer is equal to the number of desired outputs required from the network. We also use **a loss function** to calculate *the deviation between the actual values and the output* of our network, this helps in learning the weights of a neural network.

Once you are familiar with the basic terminology of neural networks mentioned above. It is not difficult *to visualize the training process for a neural network*. We start by building a neural network keeping the number of neurons in each layer **according to the rules** mentioned in the paragraph before this. The number of hidden layers in a neural network is also a hyperparameter just like the number of neurons in a hidden layer, we will discuss this later.

Once, we have built our neural network. Our next step is **to initialize the weights and the biases**, we try to *keep this initialization random* so that all our neuron learn something different. However, we do not need this randomness in case of biases and they can be **initialized with zeros**. These weights and biases are also called **learnable parameters** as well because we learn them over the cause of training.

Now, to learn these parameters we first need to generate some output so that we can compare it with the actual values and start learning from them. *To calculate the output of the network we need the output of each neuron* which can be calculated by first multiplying each input coming to the neuron with the weights assigned for each input, **summing the products**, adding the bias term to the sum and then applying some non-linearity.

**This function** can be represented by an equation like this **f(x1,x2,...,xn) = RELU(w1*x1 + w2*x2 + ... + wn*xn + b)**. Where *RELU is the non-linear function*, *Ws are the weights*, *Xs* are the inputs and *b* is a bias term. After calculating this result, we pass on the result to each neuron in the next layer.

This process as a whole is known as a **forward pass**. We use this t*o predict results* for given inputs to a neural network. The forward pass is sufficient when, predicting results but for the training purposes, we need to go further and devise or use a loss function **to calculate a deviation** between our prediction and actual data. There are a variety of choices for loss functions that we can pick from or devise our own depending on the nature of the problem we are dealing with.

**The actual learning** starts right after the calculation of the loss, our goal is to minimize this loss and the approach we use for this is called **backpropagation**. What we do in backpropagation is that we take the partial derivatives of the loss with respect to each weight and each bias and try* to update the weights and biases* in the opposite direction of the derivatives because we want to decrease the loss.

We usually use **this formula** to update the weights: **Wnew = Wold - alpha*(partial derivative of loss with respect to Wold)**. All other variables are self-explanatory except for alpha which is known as the *learning rate*. This learning rate basically defines the magnitude of the step that we are going to take to update the weights, we do not want this alpha to be big so that we *do not keep oscillating* and miss the values of Ws that give the best result.

This does not mean that we should always keep alpha very very small because doing this can really slow down our learning as the step becomes *very small to produce any significant improvement*.

Once we start the training it is helpful **to plot a graph for training loss** and **validation loss** after each iteration. We can decide from looking at these curves whether the model *in underfitting*, *overfitting* or is a good fit for the data. If the training loss is not decreasing after two to three iterations or **is increasing** and all other calculations like partial derivatives are correct then it is underfitting the training data.

This means that *the network is not complex enough to map this relationship* and probably needs *more neurons and layers* to be included. Another problem that a neural network can suffer from is overfitting this is *the case when the validation loss is higher than the training loss*. This case usually occurs when we **make our neural network overly complex** such that it becomes specific to the training data and does not generalize the overall data. This model will **perform poorly in real life settings**.

As we train our neural network we **get a higher loss** for **higher values** of the weights and in turn, the values for these *weights are penalized* and are kept small in *magnitude* by the model to avoid the higher losses. **Dropout** is a technique which is used during the training of a neural network to *avoid dependency on certain neurons* in the network. It is done by choosing a **random probability** value and that number of random neurons in left out during training in each iteration.

Different neurons are left out during each iteration of the network. **Reducing the complexity** of the network simply means reducing the weights of the networks by removing neurons or layers in the network. Data augmentation means increasing the data in our hand so that our *training data is not too small* for the network to overfit. Data augmentation can be performed in various ways depending on the type of data for example in the case of images it can be done by **blurring some images**, **flipping some images** and **performing some other operations**. If done properly data augmentation can be a very good step in the betterment of the performance of the network.

If we set all the weights to be zero, then all the neurons in all the layers perform *the same calculations* and learn same things and the neural network fails to generalize the overall aspects of data which does not help in improving the **performance of the network**. Whereas the random initialization helps in breaking the symmetry and each neuron learns something different from the training. It is also important *to keep the values of these weights near to zero* to keep the values of weights compact and *without high standard deviation*.

Another approach to initialize the weights **keeping in mind the size of the previous layer** which helps in attaining a global minimum of the loss function faster and more efficiently. The weights are still random but differ in range depending on the size of the previous layer of neurons and help in *faster convergence*.

Training also requires careful *fine-tuning of hyperparameters* like looking at the *loss plots*, deciding the number of iterations to run and adjusting the learning rata in between the iterations.

Neural networks are very powerful learning models and are widely used these days in fields *object detection*, *language translation*, *speech recognition*, **cancer detection**, *autonomous driving* and many more. Another approach to using neural networks is reinforcement learning which does not have a great *deal of data as in deep learning* and is gaining real popularity among the researchers.

#1. Introduction to Artificial Intelligence and Neural Networks

#2. Neural Networks Basic Terminology and Learning

#3. Advanced Practices for Training Neural Networks

#4. Splitting of Dataset for Validation and Testing

#5. Underfitting and Overfitting

#6. Remedies for overfitting

#7. Initialization of Weights

#8. Conclusion

Ian Melnik

Author of the post

Customer Review

Blockchain-based digital asset platform