How to make a neural network on JavaScript

Learn to create your own neural networks on JavaScript with an example and understanding of the principles of their work.

Creating a Neural Network with JavaScript

It is possible to create a neural network using JavaScript – a programming language that is commonly used for web development. Neural networks are used to process data and recognize patterns, and can be used for many different applications such as image classification, object recognition, and speech recognition. This tutorial will show you how to create a basic neural network with JavaScript.

Step 1: Set up the Network Architecture

The first step in creating a neural network is to set up the network architecture. This involves deciding how many layers the network will have, how many neurons each layer will have, and the type of activation functions that will be used. For this example, we will create a basic three-layer network with two input neurons, two hidden neurons, and one output neuron. We will use the ReLU (Rectified Linear Unit) activation function for the hidden layer, and the sigmoid activation function for the output layer.


let numInputs = 2;
let numHidden = 2;
let numOutputs = 1;

let activationFunctionHidden = 'relu';
let activationFunctionOutput = 'sigmoid';

Step 2: Create the Network Weights and Biases

Next, we need to create the weights and biases that will be used in the network. Weights and biases are parameters that determine the output of the network. The weights are the connection strengths between neurons, and the biases determine the output of a neuron before any input is applied. We will create an array of weights and an array of biases for each layer in the network.


let weightsInputToHidden = Array(numInputs).fill().map(() => Array(numHidden).fill(0));
let weightsHiddenToOutput = Array(numHidden).fill().map(() => Array(numOutputs).fill(0));

let biasHidden = Array(numHidden).fill(0);
let biasOutput = Array(numOutputs).fill(0);

Step 3: Create the Network Functions

The next step is to create the functions that will be used to calculate the output of the network. We will need three functions: one to calculate the weighted sum of the inputs to a neuron, one to apply the activation function to the weighted sum, and one to calculate the output of the network.


// Calculate the weighted sum of the inputs to a neuron
function weightedSum(inputs, weights, bias) {
  let sum = 0;
  for (let i = 0; i < inputs.length; i++) {
    sum += inputs[i] * weights[i];
  }
  return sum + bias;
}

// Apply the activation function to a weighted sum
function activation(sum, type) {
  if (type === 'relu') {
    return Math.max(0, sum);
  } else if (type === 'sigmoid') {
    return 1 / (1 + Math.exp(-sum));
  }
}

// Calculate the output of the network
function networkOutput(inputs) {
  // Calculate the weighted sum of the inputs to the hidden layer
  let weightedSumHidden = weightedSum(inputs, weightsInputToHidden, biasHidden);
  
  // Apply the activation function to the weighted sum of the hidden layer
  let activationHidden = activation(weightedSumHidden, activationFunctionHidden);
  
  // Calculate the weighted sum of the hidden layer to the output layer
  let weightedSumOutput = weightedSum(activationHidden, weightsHiddenToOutput, biasOutput);
  
  // Apply the activation function to the weighted sum of the output layer
  let output = activation(weightedSumOutput, activationFunctionOutput);
  
  return output;
}

Step 4: Train the Network

Finally, we need to train the network so that it can learn to recognize patterns. This involves adjusting the weights and biases so that the network can accurately predict the output when given an input. We can use a technique called backpropagation to adjust the weights and biases based on the difference between the predicted output and the expected output.


// Train the network
function train(inputs, targets, numIterations) {
  // Repeat the training process numIterations times
  for (let i = 0; i < numIterations; i++) {
    // Calculate the output of the network
    let output = networkOutput(inputs);
    
    // Calculate the error
    let error = targets - output;
    
    // Adjust the weights and biases
    adjustWeights(error);
  }
}

// Adjust the weights and biases
function adjustWeights(error) {
  // Calculate the adjustments for the hidden layer
  let hiddenAdjustments = weightsHiddenToOutput.map(weight => error * activation(weightedSumHidden, activationFunctionHidden) * weight);
  
  // Calculate the adjustments for the input layer
  let inputAdjustments = weightsInputToHidden.map(row => row.map(weight => 
    error * activation(weightedSumOutput, activationFunctionOutput) * activation(weightedSumHidden, activationFunctionHidden) * weight
  ));
  
  // Adjust the weights and biases
  weightsHiddenToOutput = weightsHiddenToOutput.map((weight, i) => weight + hiddenAdjustments[i]);
  weightsInputToHidden = weightsInputToHidden.map((row, i) => row.map((weight, j) => weight + inputAdjustments[i][j]));
  biasHidden = biasHidden.map((bias, i) => bias + hiddenAdjustments[i]);
  biasOutput = biasOutput.map(bias => bias + error * activation(weightedSumOutput, activationFunctionOutput));
}

And that's it! We have now created a neural network with JavaScript that can learn to recognize patterns. This is just a basic example of a neural network, but it can be extended and adapted to create more complex networks.

javascript