What Is a Neuron?

A voting booth in your brain.

Think of it like a voting booth. Three friends each send you a signal — maybe weak, maybe strong. You multiply each signal by how much you trust that friend (that's the weight). You add up all the votes, plus a little nudge called the bias (your default mood). Then you decide: do I fire, or stay quiet? That decision is the activation function.

That's it. That's the entire computation a neuron does. And AI is made of millions of these.

Biological neurons vs artificial neurons.

Artificial neurons were inspired by biological ones, but they are not copies. Understanding the differences helps you see what AI can and cannot do:

Inside a single artificial neuron.

This diagram shows the exact math from the code example below. Each input is multiplied by its weight, the products are summed, bias is added, and the activation function makes the final decision. The neuron fires because 0.80 is positive — ReLU lets it through unchanged.

The building blocks of every neuron.

Every artificial neuron does the same three-step dance: multiply inputs by weights, sum everything plus a bias, and decide whether to fire via an activation function. Here is the exact math in code:

import numpy as np

# Three inputs and their weights
inputs  = np.array([0.50, 0.30, 0.70])
weights = np.array([0.80, -0.40, 0.60])
bias    = 0.10

# Step 1: weighted sum + bias
z = np.dot(inputs, weights) + bias
print(f"weighted sum z = {z:.4f}")  # z = 0.7200

# Step 2: activation function (ReLU)
output = max(0, z)
print(f"ReLU output   = {output:.4f}")  # output = 0.7200

Reading the code: np.dot() multiplies each input by its matching weight, then adds all the results together. Input 1 (0.50) × Weight 1 (0.80) = 0.40, Input 2 (0.30) × Weight 2 (-0.40) = -0.12, Input 3 (0.70) × Weight 3 (0.60) = 0.42. Add them up: 0.40 + (-0.12) + 0.42 = 0.70. Plus the bias (0.10) = 0.80. Then ReLU checks: is 0.80 positive? Yes → pass it through. That is the entire computation.

Don't worry if code isn't your thing — the voting analogy above captures the same idea. The code is here for learners who want to see the exact math.

Why activation functions are the secret ingredient.

This is the single most important concept in neural networks. Without activation functions, a network with 1000 layers is mathematically identical to a network with 1 layer. Here is why:

Three activation functions you need to know.

Every activation function takes the weighted sum z and transforms it. Here they are in Python — copy this code and run it yourself:

import numpy as np

def step(z):
    """Historical (1957). Binary: fire or don't."""
    return 1 if z >= 0 else 0

def relu(z):
    """Modern standard. Simple, fast, effective."""
    return max(0, z)

def sigmoid(z):
    """Outputs a probability between 0 and 1."""
    return 1 / (1 + np.exp(-z))

# Try them with the same input
z = 0.72
print(f"step({z})    = {step(z)}")       # 1
print(f"relu({z})    = {relu(z)}")       # 0.72
print(f"sigmoid({z}) = {sigmoid(z):.4f}") # 0.6726

# Now try with a negative input
z = -1.5
print(f"step({z})    = {step(z)}")       # 0
print(f"relu({z})    = {relu(z)}")       # 0
print(f"sigmoid({z}) = {sigmoid(z):.4f}") # 0.1824

Notice: Step and ReLU both output 0 for negative inputs, but sigmoid still outputs 0.18 — it never fully "turns off." That is why sigmoid is useful for probability outputs (like "92% chance this is spam") but ReLU is preferred for the hidden layers inside the network because it trains faster and more reliably.

Live neuron — move the sliders and watch.

Try setting all weights to 0. Then try a large negative bias. Notice how the ReLU activation clips negative values to zero — this is the “fire or stay silent” decision.

Test your understanding.