How to Train a Neural Network with TensorFlow :
Step 1: Importing the libraries
We are going to import the required libraries.
Python
# Importing the libraries import pandas as pd import numpy as np from tensorflow import keras from tensorflow.keras import layers from sklearn.model_selection import train_test_split |
Step 2: Importing the data
The data we used for this example are generated randomly with Numpy. In this data x and y are the point of coordinates and the color feature is the target value that was generated randomly which is in binary representing Red – 1 , Blue – 0.
Python
# Importing the data df = pd.read_csv( 'data.txt' ) |
The data will look like:
Step 3: Splitting the data
Now we are going to split the dataset into train and test splits to evaluate the model with the unseen data and check its accuracy.
Python
# split the data into train and test set train, test = train_test_split( df, test_size = 0.2 , random_state = 42 , shuffle = True ) |
Step 4: Constructing the input
In this step, we are going to construct the input we need to feed into a network. For simplicity and for the model’s sake we are going to stack the two features of the data into x and the target variable as y. We use numpy.column_stack() to stack the
Python
# Constructing the input x = np.column_stack((train.x.values, train.y.values)) y = train.color.values |
Step 5: Building a model
Now we are going to build a simple neural network to classify the color of the point with two input nodes and a hidden layer and an output layer with relu and sigmoid activation functions, and sparse categorical cross-entropy loss function and this is going to be a fully connected feed-forward network.
Python
# Defining the model model = keras.Sequential([ keras.layers.Dense( 4 , input_shape = ( 2 ,), activation = 'relu' ), keras.layers.Dense( 2 , activation = 'sigmoid' ) ]) # Compiling the model model. compile (optimizer = 'adam' , loss = keras.losses.SparseCategoricalCrossentropy(), metrics = [ 'accuracy' ]) # fitting the model model.fit(x, y, epochs = 10 , batch_size = 8 ) |
Output:
If we evaluate the model with unseen data it will give a very low amount of accuracy,
Python
# Evaluating the model x = np.column_stack((test.x.values, test.y.values)) y = test.color.values model.evaluate(x, y, batch_size = 8 ) |
Step 6: Building a better model
Now we are going to improve the model with a few extra hidden layers and a better activation function ‘softmax’ in the output layer and built a better neural network.
Python
# Defining the model model_better = keras.Sequential([ keras.layers.Dense( 16 , input_shape = ( 2 ,), activation = 'relu' ), keras.layers.Dense( 32 , activation = 'relu' ), keras.layers.Dense( 32 , activation = 'relu' ), keras.layers.Dense( 2 , activation = 'softmax' ) ]) # Compiling the model model_better. compile (optimizer = 'adam' , loss = keras.losses.SparseCategoricalCrossentropy(), metrics = [ 'accuracy' ]) # Constructing the input x = np.column_stack((train.x.values, train.y.values)) y = train.color.values # fitting the model model_better.fit(x, y, epochs = 10 , batch_size = 8 ) |
Output:
Step 7: Evaluating the model
Finally, if we evaluate the model we can clearly see that the accuracy of the model on unseen data has been improved from 66 -> 85. So we built an efficient model.
Artificial Neural Network in TensorFlow
In this article, we are going to see some basics of ANN and a simple implementation of an artificial neural network. Tensorflow is a powerful machine learning library to create models and neural networks.
So, before we start What are Artificial neural networks? Here is a simple and clear definition of artificial neural networks. So long story in short artificial neural networks is a technology that mimics a human brain to learn from some key features and classify or predict in the real world. An artificial neural network is composed of numbers of neurons which is compared to the neurons in the human brain.
It is designed to make a computer learn from small insights and features and make them autonomous to learn from the real world and provide solutions in real-time faster than a human.
A neuron in an artificial neural network, will perform two operations inside it
- Sum of all weights
- Activation function
So a basic Artificial neural network will be in a form of,
- Input layer – To get the data from the user or a client or a server to analyze and give the result.
- Hidden layers – This layer can be in any number and these layers will analyze the inputs with passing through them with different biases, weights, and activation functions to provide an output
- Output Layer – This is where we can get the result from a neural network.
So as we know the outline of the neural networks, now we shall move to the important functions and methods that help a neural network to learn correctly from the data.
Note: Any neural network can learn from the data but without good parameter values a neural network might not able to learn from the data correctly and will not give you the correct result.
Some of the features that determine the quality of our neural network are:
- Layers
- Activation function
- Loss function
- Optimizer
Now we shall discuss each one of them in detail,
The first stage of our model building is:
Python3
# Defining the model model = keras.Sequential([ keras.layers.Dense( 32 , input_shape = ( 2 ,), activation = 'relu' ), keras.layers.Dense( 16 , activation = 'relu' ), keras.layers.Dense( 2 , activation = 'sigmoid' ) ]) |