The Artificial Neuron: Building the Foundation of Neural Networks

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 Python. 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 only NumPy . This practical, code-focused approach will give you a much deeper understanding of neural networks than simply using existing 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

Join the 1M+ learners on CodeSignal

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

Implementing the Forward Pass

The "forward pass" refers to the process of calculating the neuron's output given a set of inputs. This is where we implement the mathematical model we discussed earlier:

Python

def forward(self, inputs):
    """
    Calculate the neuron's output (weighted sum + bias).
    inputs: A NumPy array of input features (must match n_inputs).
    """
    # Input validation ensures our calculations will work correctly
    if inputs.shape[0] != self.weights.shape[0]:
        raise ValueError(
            f"Input size {inputs.shape[0]} does not match neuron's "
            f"expected input size {self.weights.shape[0]}."
        )
    
    # Calculate the weighted sum using NumPy's optimized dot product function
    weighted_sum = np.dot(inputs, self.weights)
    
    # Add the bias term to get the final output
    output = weighted_sum + self.bias
    return output

def forward(self, inputs):
    """
    Calculate the neuron's output (weighted sum + bias).
    inputs: A NumPy array of input features (must match n_inputs).
    """
    # Input validation ensures our calculations will work correctly
    if inputs.shape[0] != self.weights.shape[0]:
        raise ValueError(
            f"Input size {inputs.shape[0]} does not match neuron's "
            f"expected input size {self.weights.shape[0]}."
        )
    
    # Calculate the weighted sum using NumPy's optimized dot product function
    weighted_sum = np.dot(inputs, self.weights)
    
    # Add the bias term to get the final output
    output = weighted_sum + self.bias
    return output

This forward method is the heart of our neuron. It takes an array of inputs and performs these steps:

First, it validates that the input array has the correct number of elements.
Then it calculates the weighted sum using np.dot(), which efficiently computes the dot product.
Finally, it adds the bias to get the final output value.

The use of NumPy's dot() function is much more efficient than writing a loop to multiply and sum each input-weight pair, especially when dealing with larger networks later on.

Introduction

Recap: Biological Inspiration

The Mathematical Model of a Neuron

Join the 1M+ learners on CodeSignal

Creating a Neuron Class

Implementing the Forward Pass

Testing Your Neuron

Conclusion and Next Steps