# Hi, I'm Chris ðŸ‘‹

I am an iOS developer / freelancer / contractor based in Australia.
I specialise in building well-structured app platforms for companies to build their long-term app strategies upon.
I have a broad array of experience from my work at Google, News Corp, Fox Sports, NineMSN, FetchTV, Coles, Woolworths, Trust Bank, and Westpac.
Please see my portfolio, then get in touch if I can be of service!

Hi all, hereâ€™s the fourth on my series on neural networks / machine learning / AI from scratch. In the previous articles (please read them first!), I explained how a single neuron works, then how to calculate the gradient of its weight and bias, and how you can use that gradient to train the neuron. In this article, Iâ€™ll explain how to determine the gradients when you have many layers of many neurons, and use those gradients to train the neural net.

In my previous articles in this series, I used spreadsheets to make the maths easier to follow along. Unfortunately I donâ€™t think Iâ€™ll be able to demonstrate this topic in a spreadsheet, I think itâ€™d get out of hand, so Iâ€™ll keep it in code. I hope you can still follow along!

## Data model

Pardon my pseudocode:

``````class Net {
layers: [Layer]
}

class Layer {
neurons: [Neuron]
}

class Neuron {
value: float
bias: float
weights: [float]
}
``````

Explanation:

• Layers: The neural net is made up of multiple layers. The first one in the array is the input layer, the last one is the output layer.
• Neurons: The neurons that make up a layer. Each layer will typically have different numbers of neurons.
• Value: The output of each neuron.
• Bias: The bias of each neuron.
• Weights: Input weights for each neuron. This arrayâ€™s size will be the number of inputs to this layer. For the first layer, this will be the number of inputs (aka features) to the neural net. For subsequent layers, this will be the count of neurons in the previous layer.
• Activation Gradient: These are the gradients of each neuron, chained to the latter layers via the magic of calculus. This is also equal to the gradient of the bias too. Maybe reading my second article in this series will help understand what this gradient means :)

## High(ish) level explanation

What weâ€™re trying to achieve here is to use calculus to determine the â€˜gradientâ€™ of every bias and every weight in this neural net. In order to do this, we have to â€˜back propagateâ€™ these gradients from the back to the front of the â€˜layersâ€™ array.

Concretely - if, say, we had 3 layers: weâ€™d figure out the gradients of the activation functions of layers[2], then use those values to calculate the gradients of layers[1], and then layers[0].

Once we have the gradients of the activation functions for each neuron in each layer, itâ€™s easy to figure out the gradient of the weights and bias for each neuron.

And, as demonstrated in my previous article, once we have the gradients, we can â€˜nudgeâ€™ the weights and biases in the direction that their gradients say, thus train the neural net.

## Steps

Training and determining the gradients go hand-in-hand, as you need the inputs to calculate the values of each neuron in the net, and you need the targets (aka desired outputs) to determine the gradients. Thus itâ€™s a three step process:

• Forward pass (calculate the Layer.values)
• Train the weights and biases (adjust the Layer.biases and Layer.weights)

## Forward pass

This pass fills in the â€˜valueâ€™ fields.

• The first layerâ€™s neurons must have the same number of weights as the number of inputs.
• Each neuronâ€™s value is calculated as tanh(bias + sum(weights * inputs)).
• Since tanh is used as the activation function, this neural net can only work with inputs and outputs and targets that are in the range -1 to +1.

Forward pass pseudocode:

``````for layer in layers, first to last {
if this is the first layer {
for neuron in layer.neurons {
total = neuron.bias
for weight in neuron.weights {
total += weight * inputs[weight_index]
}
neuron.value = tanh(total)
}
} else {
previous_layer = layers[layer_index - 1]
for neuron in layer.neurons {
total = neuron.bias
for weight in neuron.weights {
total += weight * previous_layer.neuron[weight_index].value
}
neuron.value = tanh(total)
}
}
}
``````

## Backward pass (aka backpropagation)

This fills in the â€˜activation_gradientâ€™ fields.

• Note that when iterating the layers here, you must go last to first.
• The â€˜targetsâ€™ are the array of output value(s) from the training data.
• The last layer must have the same number of neurons as the number of targets.
• The `(1 - value^2) * ...` are calculus equations for determining gradients.

Backward pass pseudocode:

``````for layer in reversed layers, last to first {
if this is the last layer {
for neuron in layer.neurons {
(1 - neuron.value^2) *
(value - targets[neuron_index])
}
} else {
next_layer = layers[layer_index + 1]
for this_layer_neuron in layer.neurons {
for next_layer_neuron in next_layer.neurons {
next_layer_neuron.weights[this_layer_neuron_index]
}
(1 - this_layer_neuron.value^2) *
}
}
}
``````

## Training pass

Now that you have the gradients, you can adjust the biases/weights to train it to better.

Iâ€™ll skim over this as itâ€™s covered in my earlier articles in this series. The gist of it is that, for each neuron, the gradient is calculated for the bias and every weight, and the bias/weights are adjusted a little to â€˜descend the gradientâ€™. Perhaps my pseudocode might make more sense:

``````learning_rate = 0.01 // Aka 1%
for layer in layers {
if this is the first layer {
for neuron in layer.neurons {
for weight in neuron.weights {
}
}
} else {
previous_layer = layers[layer_index - 1]
for neuron in layer.neurons {
for weight in neuron.weights {
previous_layer.neurons[weight_index].value *
}
}
}
}
``````

## Rust demo

Because Iâ€™m a Rust tragic, hereâ€™s a demo. Itâ€™s kinda long, sorry, not sorry. It was fun to write :)

This trains a neural network to calculate the area and circumference of a rectangle, given the width and height as inputs.

• Width and height are scaled to the range 0.1 - 1. because thatâ€™s the range that the tanh activation function supports.
• Target values are also scaled to be in the range that tanh supports.
• Initial biases and weights are randomly assigned.

ðŸ¦€ðŸ¦€ðŸ¦€

``````use rand::Rng;

struct Net {
layers: Vec<Layer>,
}

struct Layer {
neurons: Vec<Neuron>,
}

struct Neuron {
value: f64,
bias: f64,
weights: Vec<f64>,
}

const LEARNING_RATE: f64 = 0.001;

fn main() {

// Make a 3,3,2 neural net that inputs the width and height of a rectangle,
// and outputs the area and circumference.
let mut net = Net {
layers: vec![
Layer { // First layer has 2 weights to suit the 2 inputs.
neurons: vec![
Neuron {
value: 0.,
bias: rng.gen_range(-1. .. 1.),
weights: vec![
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
],
},
Neuron {
value: 0.,
bias: rng.gen_range(-1. .. 1.),
weights: vec![
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
],
},
Neuron {
value: 0.,
bias: rng.gen_range(-1. .. 1.),
weights: vec![
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
],
},
],
},
Layer { // Second layer neurons have the same number of weights as the previous layer has neurons.
neurons: vec![
Neuron {
value: 0.,
bias: rng.gen_range(-1. .. 1.),
weights: vec![
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
],
},
Neuron {
value: 0.,
bias: rng.gen_range(-1. .. 1.),
weights: vec![
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
],
},
Neuron {
value: 0.,
bias: rng.gen_range(-1. .. 1.),
weights: vec![
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
],
},
],
},
Layer { // Last layer has 2 neurons to suit 2 outputs.
neurons: vec![
Neuron {
value: 0.,
bias: rng.gen_range(-1. .. 1.),
weights: vec![
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
],
},
Neuron {
value: 0.,
bias: rng.gen_range(-1. .. 1.),
weights: vec![
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
rng.gen_range(-1. .. 1.),
],
},
],
},
],
};

// Train.
let mut cumulative_error_counter: i64 = 0; // These vars are for averaging the errors.
let mut area_error_percent_sum: f64 = 0.;
let mut circumference_error_percent_sum: f64 = 0.;
for training_iteration in 0..100_000_000 {
// Inputs:
let width: f64 = rng.gen_range(0.1 .. 1.);
let height: f64 = rng.gen_range(0.1 .. 1.);
let inputs: Vec<f64> = vec![width, height];

// Targets (eg desired outputs):
let area = width * height;
let circumference_scaled = (height * 2. + width * 2.) * 0.25; // Scaled by 0.25 so it'll always be in range 0..1.
let targets: Vec<f64> = vec![area, circumference_scaled];

// Forward pass!
for layer_index in 0..net.layers.len() {
if layer_index == 0 {
let layer = &mut net.layers[layer_index];
for neuron in &mut layer.neurons {
let mut total = neuron.bias;
for (weight_index, weight) in neuron.weights.iter().enumerate() {
total += weight * inputs[weight_index];
}
neuron.value = total.tanh();
}
} else {
// Workaround for Rust not allowing you to borrow two different vec elements simultaneously.
let previous_layer: &Layer;
unsafe { previous_layer = & *net.layers.as_ptr().add(layer_index - 1) }
let layer = &mut net.layers[layer_index];
for neuron in &mut layer.neurons {
let mut total = neuron.bias;
for (weight_index, weight) in neuron.weights.iter().enumerate() {
total += weight * previous_layer.neurons[weight_index].value;
}
neuron.value = total.tanh();
}
}
}

// Let's check the results!
let outputs: Vec<f64> = net.layers.last().unwrap().neurons
.iter().map(|n| n.value).collect();
let area_error_percent = (targets[0] - outputs[0]).abs() / targets[0] * 100.;
let circumference_error_percent = (targets[1] - outputs[1]).abs() / targets[1] * 100.;
area_error_percent_sum += area_error_percent;
circumference_error_percent_sum += circumference_error_percent;
cumulative_error_counter += 1;
if training_iteration % 10_000_000 == 0 {
println!("Iteration {} errors: area {:.3}%, circumference: {:.3}% (smaller = better)",
training_iteration,
area_error_percent_sum / cumulative_error_counter as f64,
circumference_error_percent_sum / cumulative_error_counter as f64);
area_error_percent_sum = 0.;
circumference_error_percent_sum = 0.;
cumulative_error_counter = 0;
}

// Backward pass! (aka backpropagation)
let layers_len = net.layers.len();
for layer_index in (0..layers_len).rev() { // Reverse the order.
if layer_index == layers_len - 1 { // Last layer.
let layer = &mut net.layers[layer_index];
for (neuron_index, neuron) in layer.neurons.iter_mut().enumerate() {
(1. - neuron.value * neuron.value) *
(neuron.value - targets[neuron_index]);
}
} else {
// Workaround for Rust not allowing you to borrow two different vec elements simultaneously.
let next_layer: &Layer;
unsafe { next_layer = & *net.layers.as_ptr().add(layer_index + 1) }
let layer = &mut net.layers[layer_index];
for (this_layer_neuron_index, this_layer_neuron) in layer.neurons.iter_mut().enumerate() {
let mut next_layer_gradient_sum: f64 = 0.;
for next_layer_neuron in &next_layer.neurons {
next_layer_neuron.weights[this_layer_neuron_index];
}
(1. - this_layer_neuron.value * this_layer_neuron.value) *
}
}
}

// Training pass!
for layer_index in 0..net.layers.len() {
if layer_index == 0 {
let layer = &mut net.layers[layer_index];
for neuron in &mut layer.neurons {
for (weight_index, weight) in neuron.weights.iter_mut().enumerate() {
inputs[weight_index] *
}
}
} else {
// Workaround for Rust not allowing you to borrow two different vec elements simultaneously.
let previous_layer: &Layer;
unsafe { previous_layer = & *net.layers.as_ptr().add(layer_index - 1) }
let layer = &mut net.layers[layer_index];
for neuron in &mut layer.neurons {
for (weight_index, weight) in neuron.weights.iter_mut().enumerate() {
previous_layer.neurons[weight_index].value *
}
}
}
}
}
}
``````

Which outputs:

``````Iteration 0 errors: area 223.106%, circumference: 13.175% (smaller = better)
Iteration 10000000 errors: area 17.861%, circumference: 1.123% (smaller = better)
Iteration 20000000 errors: area 14.656%, circumference: 0.790% (smaller = better)
Iteration 30000000 errors: area 14.516%, circumference: 0.698% (smaller = better)
Iteration 40000000 errors: area 6.359%, circumference: 0.882% (smaller = better)
Iteration 50000000 errors: area 2.966%, circumference: 0.875% (smaller = better)
Iteration 60000000 errors: area 2.769%, circumference: 0.807% (smaller = better)
Iteration 70000000 errors: area 2.600%, circumference: 0.698% (smaller = better)
Iteration 80000000 errors: area 2.401%, circumference: 0.573% (smaller = better)
Iteration 90000000 errors: area 2.166%, circumference: 0.468% (smaller = better)
``````

Which you can see the error percentage drop down as it â€˜learnsâ€™ to calculate the area and circumference of a rectangle. Magic!

Thanks for reading, hope you found this helpful, at least a tiny bit, God bless!

Photo by Jonas Hensel on Unsplash

You can read more of my blog here in my blog archive.

## Chris Hulbert

(Comp Sci, Hons - UTS)

iOS Developer (Freelancer / Contractor) in Australia.

I have worked at places such as Google, Cochlear, Assembly Payments, News Corp, Fox Sports, NineMSN, FetchTV, Coles, Woolworths, Trust Bank, and Westpac, among others. If you're looking for help developing an iOS app, drop me a line!

Get in touch:
[email protected]
github.com/chrishulbert