Artificial Neuron

Why Does This Exist?

Your model gets numbers, not opinions. A pixel brightness, a word count, a sensor reading. Something has to turn that row of numbers into one call: keep or flag, yes or no, how much.

Without that unit you would hand-write the rule for every input combo. That breaks the moment inputs interact, because a strong signal in one column can cancel a weak one in another and no fixed cutoff sees it. Give each input its own volume knob instead, add the results, and you have a unit that can learn the rule from examples. Stacks of these units run modern nets.

This page covers the single unit: the weighted sum, the bias nudge, and the bend after it. The bends get their own page in activation functions. Stacks get theirs in multi-layer perceptron. How the knobs get learned lives in gradient descent. One idea you need first: a weighted sum, the same move linear regression uses to mix inputs. Here you add a bias and a bend after the mix.

Think of It Like This

How It Actually Works

A neuron takes a short list of numbers and returns one number. Call the inputs $x_1, x_2$, plain readings like 1.0 and 0.5. Call the weights $w_1, w_2$, one volume knob per input. Call the bias $b$, a single nudge added at the end. The pre-activation total is $z$, and the final output is $y$ after the bend.

The two steps

First comes the weighted sum. Multiply each input by its weight, add them, then add the bias:

Weights set direction and strength. A positive weight says more input means more output. A negative weight says more input pushes output down. The bias slides the whole decision point. With zero bias the boundary must pass through the origin. With a bias it can sit wherever the data needs it.

Then comes the activation. Pass $z$ through a bend $f$, so $y = f(z)$. The classic bend here is the sigmoid, $f(z) = 1 / (1 + e^{-z})$, which squeezes any total into the range 0 to 1. You will meet the full menu of bends in activation functions. The perceptron used a hard step instead: 1 when $z$ reaches 0, else 0. Keep the split clear. The sum mixes. The bend decides the shape.

Worked example

Take two inputs, two weights, and one bias:

Multiply first:

Multiply second:

Add the products:

Add the bias to get $z$:

Push $z = 0.60$ through a sigmoid. First the exponential term:

Then the output:

Rounded, $y \approx 0.65$. Since $0.65$ sits above $0.5$, a step rule would fire with a 1, and a ReLU would pass through $0.60$. The diagram above draws these same numbers: 1.0 and 0.5 on the left, 0.80 and minus 0.30 on the edges, 0.60 in the middle, 0.65 on the way out.

Code

The point is the check: the same products, the same sum, the same bend, printed for real.

1import math2
3
4def neuron(x1: float, x2: float) -> tuple[float, float]:5    w1: float = 0.86    w2: float = -0.67    b: float = 0.18    z: float = w1 * x1 + w2 * x2 + b9    y: float = 1.0 / (1.0 + math.exp(-z))10    return z, y11
12
13z, y = neuron(1.0, 0.5)14print(f"z {z:.2f} y {y:.4f}")  # -> z 0.60 y 0.645715print(f"fires {y > 0.5}")  # -> fires True

The printout matches the hand computation: $z$ is $0.60$, $y$ is $0.6457$, and the unit fires because $0.6457$ clears $0.5$.

Watch Out For

The Quick Version

• An artificial neuron forms $z$ from inputs 1.0 and 0.5 as 0.8 times 1.0 plus minus 0.6 times 0.5 plus bias 0.1, which gives $z = 0.6$.
• A sigmoid turns $z = 0.6$ into about $0.65$, so the same unit can feed a soft score or a hard yes when the score clears 0.5.
• Weights set how much each input counts and in which direction, while the bias slides the decision point away from zero.
• Without a bend after the sum, stacked neurons collapse into one straight rule and cannot learn curves.
• One neuron draws one boundary. Curves, regions, and stacked decisions need many neurons wired in layers.

What to Read Next

• Gradient Descent
• Activation Functions