Building an Artificial Neuron from Scratch in JavaScript | CodeSignal Learn

Building an Artificial Neuron from Scratch in JavaScript | CodeSignal Learn

Introduction

Welcome to the second lesson in our course " Neural Network Fundamentals: Neurons and Layers "! Now that you've been introduced to the basics of neural networks, we're ready to dive deeper into their core components. In this lesson, we'll focus on the fundamental building block of neural networks: the artificial neuron . You'll learn what a neuron is, how it processes information, and implement a simple artificial neuron in JavaScript . By the end of this lesson, you'll understand how an artificial neuron works, both conceptually and mathematically, and you'll have hands-on experience coding one from scratch using math.js . This practical, code-focused approach will give you a much deeper understanding of neural networks than simply using existing high-level libraries.

Recap: Biological Inspiration

Before diving into code, let's recap where the concept of an artificial neuron comes from. Artificial neurons are inspired by the biological neurons in our brains. In your brain, a biological neuron receives signals from other neurons through structures called dendrites . These signals are processed in the cell body, and if the combined signal is strong enough, the neuron "fires," sending a signal through its axon to other neurons. An artificial neuron mimics this behavior in a simplified way: Inputs represent the signals received from other neurons (like dendrites); Weights represent the strength of each connection; Bias represents the neuron's tendency to fire regardless of inputs; Activation function (which we'll cover in future lessons) mimics the "firing" behavior. This simple model, when combined with many other neurons, forms the basis of neural networks that can learn complex patterns and make predictions. The beauty of this approach is that even though individual neurons perform very simple operations, their collective behavior can solve incredibly complex problems — from recognizing faces to translating languages.

The Mathematical Model of a Neuron

n

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Creating a Neuron Class

Let's implement an artificial neuron in JavaScript using the math.js library. In the CodeSignal IDE, math.js is already installed and available for use, so you do not need to install it manually. If you're working locally, you can install it with the following command: npm install mathjs Now, let's define a Neuron class that can process a specified number of input features. The neuron will initialize its weights randomly (small values) and set its bias to zero: const math = require('mathjs'); class Neuron {constructor(nInputs) {// Weights: one for each input feature, initialized randomly // Bias: a single value for the neuron, initialized to 0 this.weights = math.multiply(math.random([nInputs]), 0.1); // Small random weights this.bias = 0.0; console.log(`Neuron initialized with ${nInputs} inputs.`); console.log(`Initial weights: [${this.weights.map(w => w.toFixed(4)).join(', ')}]`); console.log(`Initial bias: ${this.bias}`);}} When you create a new neuron, you specify how many inputs it will accept. The constructor initializes: weights : An array of small random values, one for each input bias : A single value, starting at 0.0 Random initialization of weights is important to ensure that each neuron starts with a unique configuration, which is crucial for learning.

Implementing the Forward Pass

The forward pass is the process of calculating the neuron's output for a given set of inputs. This is done by computing the dot product of the input array and the weights, then adding the bias: forward(inputs) {/** * Calculate the neuron's output (weighted sum + bias). * inputs: An array of input features (must match nInputs). */ if (inputs.length !== this.weights.length) {throw new Error(`Input size ${inputs.length} does not match neuron's ` + `expected input size ${this.weights.length}.`);} // Calculate the weighted sum: dot product of inputs and weights const weightedSum = math.dot(inputs, this.weights); // Add bias const output = weightedSum + this.bias; return output;} This method checks that the input array matches the expected size, computes the weighted sum using math.dot(), and adds the bias to produce the output.

Testing Your Neuron

Let's test the neuron by creating an instance with 3 input features and passing in two different sample input arrays: if (require.main === module) {// 1. Create a neuron with 3 input features const numInputs = 3; const neuron = new Neuron(numInputs); // 2. Define two different sample input arrays const sampleInput1 = [1.0, 2.0, 3.0]; const sampleInput2 = [0.5, -1.0, 2.0]; // 3. Calculate outputs for each input const output1 = neuron.forward(sampleInput1); const output2 = neuron.forward(sampleInput2); // 4. Print the results console.log(`Output 1: ${output1}`); console.log(`Output 2: ${output2}`);} When you run this code, you'll see the neuron's initialization details, the sample inputs, and the corresponding outputs. This demonstrates how a single artificial neuron processes different input data and produces outputs based on its weights and bias.

JavaScript

const math = require('mathjs');

class Neuron {
    constructor(nInputs) {
        // Weights: one for each input feature, initialized randomly
        // Bias: a single value for the neuron, initialized to 0
        this.weights = math.multiply(math.random([nInputs]), 0.1); // Small random weights
        this.bias = 0.0;

        console.log(`Neuron initialized with ${nInputs} inputs.`);
        console.log(`Initial weights: [${this.weights.map(w => w.toFixed(4)).join(', ')}]`);
        console.log(`Initial bias: ${this.bias}`);
    }
}

JavaScript

forward(inputs) {
    /**
     * Calculate the neuron's output (weighted sum + bias).
     * inputs: An array of input features (must match nInputs).
     */
    if (inputs.length !== this.weights.length) {
        throw new Error(
            `Input size ${inputs.length} does not match neuron's ` +
            `expected input size ${this.weights.length}.`
        );
    }

    // Calculate the weighted sum: dot product of inputs and weights
    const weightedSum = math.dot(inputs, this.weights);

    // Add bias
    const output = weightedSum + this.bias;
    return output;
}

JavaScript

if (require.main === module) {
    // 1. Create a neuron with 3 input features
    const numInputs = 3;
    const neuron = new Neuron(numInputs);

    // 2. Define two different sample input arrays
    const sampleInput1 = [1.0, 2.0, 3.0];
    const sampleInput2 = [0.5, -1.0, 2.0];

    // 3. Calculate outputs for each input
    const output1 = neuron.forward(sampleInput1);
    const output2 = neuron.forward(sampleInput2);

    // 4. Print the results
    console.log(`Output 1: ${output1}`);
    console.log(`Output 2: ${output2}`);
}