{ C Language } Deep Learning From Ground Up™

Install code blocks IDE, download and set as default for C/C++ sources and gcc compiler, create a console project, build and run a hello world program to test the setup.

Examine a single input single output neural network where input times weight yields the predicted value, using a 10 threshold to classify sad or happy, with words encoded numerically later.

Learn to implement a simple single input, single output neural network in C by multiplying input by weight to produce the predicted value.

Learn how a single input drives a single input multiple output neural network to predict temperature, humidity, and air quality using weights and an output array.

Explore a single input, multiple output neural network that uses element-wise multiply of an input scalar with a weight vector to predict temperature, humidity, and air quality.

Demonstrate a three-input, single-output neural network by computing a weighted sum of temperature, humidity, and air quality to predict happiness or sadness.

Develop a multiple input single output neural network in C by computing a weighted sum of temperature, humidity, and air quality inputs to predict a value.

Harness a multiple input, multiple output neural network using temperature, humidity, and air quality to predict happiness, health, and activity. Shared inputs with different weights enable vector matrix multiplication.

Explore a multiple input multiple output neural network in C, using a weight matrix and vector input to compute three outputs—sad, sick, and active—via matrix-vector multiplication with three weight sets.

Explore how a one hidden layer neural network processes inputs through input-to-hidden and hidden-to-output weight matrices to compute predictions, using vector and matrix multiplications.

Examine a hidden layer neural network with multiple inputs and outputs, using input-to-hidden and hidden-to-output weight matrices and two matrix-vector multiplications to compute the final output.

Explore predicting, comparing, and learning by computing the squared error from predicted and expected values, then re-adjusting the weight programmatically to minimize error.

Compute the error by subtracting the predicted value from the expected value, square the difference, and return it via the find error and simple error functions; test with multiple values.

Explore the basic data types used in machine learning, including scalars, vectors, and tensors, along with their shapes and ranks. Understand how data structure and dimensions guide tensor operations.

Discover how learning reduces error by computing delta from predicted minus expected values, multiplying by inputs, and updating weights with the learning rate alpha.

Explore brute force learning in a simple neural network: predictions from input times weight are compared to expected value, then the weight adjusts to minimize error or loss across iterations.

Explore gradient descent by visualizing how updating the weight reduces error along a curve, guiding the neural network toward the zero-error destination, with overshoots and corrections.

Explore the functional description of a biological neuron, from inputs via antenna-like structures to dynamic strengthening or weakening of connections based on usage, cell body summation, and axon propagation.

Explore a supervised regression case study building a neural network to predict muscle gain from workout and rest hours, with data normalization, forward propagation, and gradient descent.

Learn how to normalize a data set by finding the maximum value and dividing each element by that max to produce a normalized output vector in C.

Learn how to randomly initialize weight matrices for a multi-layer neural network by generating matrices for input-to-hidden and hidden-to-output connections with values between 0 and 1.

Explore how activation functions add non-linearity to neural networks, transforming weighted inputs into outputs for the next layer. Compare sigmoid, tanh, and ReLU ranges and derivatives for backpropagation.

Execute forward propagation of a neural network with one hidden layer in c, building data buffers, normalizing inputs, computing z and a, and applying sigmoid activation to yield y hat.

Review calculus basics for deep learning, including derivatives, chain rule, product and sum rules, and key concepts like backpropagation and gradient descent.

Build a neural network to detect cats in 64 by 64 rgb images by flattening pixels into a 12,228 feature vector and applying a weight matrix for binary classification.

Explore the internals of a two layer neural network, computing layer inputs z using a weight matrix and biases, applying activation to obtain the hidden outputs and understanding layer dimensions.

Represent a function as a computation graph with nodes like u, v, and j, then apply backpropagation and the chain rule to compute derivatives from final output back to inputs.

Update neural network parameters by computing the squared loss from the predicted minus expected values, applying delta, and updating four parameters—weights and biases across two layers—using learning rate alpha.

Learn to replace for loops with vectorized computations using NumPy dot to compute the entire Z vector for all training examples at once, enabling efficient gradient descent.

Compute forward propagation steps in a neural network using the activation function g, then apply backpropagation by deriving with respect to parameters to update them, using the vectorization method.

Initialize parameters by creating matrices with random values and bias matrices with zeros, and learn how a function generates a matrix with given rows and columns.

Explore how neural networks organize layers and units, from the input layer a^0 to the output layer a^L, detailing the per-layer unit counts N^l and activations a^l.

Learn how broadcasting aligns shapes in arithmetic operations, enabling a smaller matrix or vector to be added to a larger matrix by duplicating its values across rows or columns.

This lecture explains overfitting and underfitting, showing how training data memorization harms generalization and how to balance bias and variance with data, regularization, or architecture changes.

Define a neural network structure in C, build a complete neural network library with a single hidden layer, and implement creation, training, prediction, saving, loading, and utilities.

Define a data object in c for neural network inputs and targets, and implement utilities to read files, create 2d float arrays, and manage memory.

Implement a function to count lines in a file and a function to read a line, using dynamic memory and reallocation for variable line lengths.

Implement a function to dynamically create a 2d array in C using malloc, returning float**, then build input and target 2d arrays and tokenize space separated data with strtok.

Implement free function, shuffle function, and build data loader to read datasets, prepare input-output data, and set up neural network training with forward, back propagation, and prediction.

Implement forward propagation in a C neural network, computing hidden layer activations with weights, bias, and sigmoid activation, then proceed to output layer calculations; backpropagation follows.

Implement the back propagation function for a simple neural network, computing error and partial derivatives, then update weights across input, hidden, and output layers with the learning rate.

Implement the NNPredict function by calling the forward pass, while initializing neural network weights and biases with random values; bias can be zeroed if convergence is slow.

Implement NNBuild and NNTrain to construct a neural network, initialize weights and biases, connect inputs to hidden and output layers, and perform forward and backward propagation to train.

Learn to implement the NNSaveModel and NNLoadModel functions by saving and loading a neural network's header (inputs, hidden neurons, outputs) along with biases and weights using file operations.

Implement the NNPrint function to display the highest-probability prediction for handwritten digits (0–9) and add a free function to release heap memory.