Neural Nets
A neural network is a computational model inspired by the human brain. It consists of interconnected nodes, called neurons, organized into layers. Each neuron takes input, performs some calculations, and produces an output. Neural networks are trained using a process called "learning" where they adjust their internal parameters (weights and biases) based on example inputs and desired outputs.
​
When you train a neural network using the example code you provided, it learns to recognize patterns in the training data. In this case, the neural network is trained to perform binary classification, specifically the XOR logical function. The training data consists of input pairs (0 or 1) and their corresponding output labels (0 or 1).
​
After training, the neural network's goal is to predict the output labels for new, unseen inputs. The printed results you see represent the neural network's predictions for the test inputs. Each value in the array corresponds to the predicted output for a specific test input.
​
For example, if the test input is [0, 0], and the predicted output is close to 0, it means that the neural network believes that [0, 0] should have an output label of 0. Similarly, if the test input is [1, 1], and the predicted output is close to 1, it means that the neural network believes that [1, 1] should have an output label of 1.
​
The accuracy of the neural network's predictions is also provided during the training process. It represents the percentage of correctly predicted outputs compared to the total number of test inputs. In the printed output, you will see the accuracy value increasing over the epochs as the neural network learns and improves its predictions.
​
In summary, a trained neural network is a computational model that has learned patterns from training data. The results represent the neural network's predictions for new inputs, and the accuracy indicates how well the neural network is performing in terms of correctly predicting outputs.
​
Keep in mind that this is a simplified explanation, and neural networks can be much more complex in practice. They are used in a wide range of applications, including image recognition, natural language processing, and many other tasks where pattern recognition and prediction are important.
​
A simple neural networks example in Visual Studio Code
​
We'll create a basic neural network that can perform binary classification using the popular Python library called TensorFlow. Here's an example code that you can run in Visual Studio Code:
This example demonstrates a simple neural network with one input layer, one hidden layer (not explicitly defined but created by the Dense layer), and one output layer. The model uses the sigmoid activation function and the Adam optimizer. It is trained on the XOR logical function, and after training, it predicts the outputs for the same inputs.
​
To run this code in Visual Studio Code, follow these steps:
​
-
Open Visual Studio Code and create a new Python file (e.g., neural_network.py).
-
Copy and paste the code into the file.
-
Save the file.
-
Open the terminal in Visual Studio Code (View -> Terminal).
-
Make sure you have the necessary dependencies installed by running pip install tensorflow numpy.
-
Run the code by executing python neural_network.py in the terminal.
​
This example provides a basic introduction to neural networks using TensorFlow. Feel free to explore further and modify the code to experiment with different architectures, datasets, and activation functions.
​
After running the example code, there will be some printed output that provides information about the training and prediction process.
Let's break down the potential printed output for each step:
​
-
Epochs and Training Progress: During the training phase, you will see the progress of each epoch along with the loss and accuracy metrics. It will display something like this
-
Epoch 1/1000 4/4 [==============================] - 0s 249us/sample - loss: 0.7854 - accuracy: 0.5000 ... Epoch 1000/1000 4/4 [==============================] - 0s 249us/sample - loss: 0.1983 - accuracy: 1.0000
This output shows the progress of each epoch, the number of samples processed, the loss value, and the accuracy achieved during each epoch.
-
Predictions: After training, the code will make predictions on the test inputs. The predictions will be printed as an array of values, representing the model's predicted outputs for each test input. It will look something like this:
[[0.04429233] [0.04063508] [0.03087872] [0.9730453 ]]
-
Each value in the array represents the predicted output for a corresponding test input.
​
The specific output will depend on the training data, the neural network model, and the number of epochs you have specified in the code. The goal is to minimize the loss value and achieve high accuracy during training, and the predictions should ideally match the expected outputs for the given test inputs.
​
Keep in mind that the output can vary depending on the random initialization of the neural network weights, so you may see slightly different results each time you run the code.
​
An addition simple example of a neural network that can be used to solve a binary classification problem.
​
The python code is:
import numpy as np
# Define the sigmoid activation function
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# Define the neural network class
class NeuralNetwork:
def __init__(self):
# Initialize the weights with random values
self.weights1 = np.random.rand(2, 3) # weights connecting input layer to hidden layer
self.weights2 = np.random.rand(3, 1) # weights connecting hidden layer to output layer
def forward(self, X):
# Propagate inputs through the network
self.hidden = sigmoid(np.dot(X, self.weights1))
self.output = sigmoid(np.dot(self.hidden, self.weights2))
return self.output
def train(self, X, y, epochs):
for _ in range(epochs):
# Forward propagation
output = self.forward(X)
# Backpropagation
error = y - output
output_delta = error * (output * (1 - output))
hidden_delta = output_delta.dot(self.weights2.T) * (self.hidden * (1 - self.hidden))
# Update weights
self.weights2 += self.hidden.T.dot(output_delta)
self.weights1 += X.T.dot(hidden_delta)
# Create a dataset for training
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])
# Create an instance of the neural network
nn = NeuralNetwork()
# Train the neural network
nn.train(X, y, epochs=10000)
# Test the neural network
test_input = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
predictions = nn.forward(test_input)
# Print the predictions
for i in range(len(test_input)):
print(f"Input: {test_input[i]} Predicted Output: {predictions[i]}")
RESULTS:
Input: [0 0] .......... Predicted Output: [0.03265749]
Input: [0 1] .......... Predicted Output: [0.98000362]
Input: [1 0] .......... Predicted Output: [0.98000388]
Input: [1 1] .......... Predicted Output: [0.00711134]
A diagram of this neural net is as follows:
​
