Practical Guide to AI & ML: Mastering Future Tech Skills

In this lesson, I introduce AI at a high level. I slowly introduce the fact that AI systems such as ChatGPT and Bard do not yet have human-like intelligence. I also introduce the topic of machine learning and how this is different to AI.

In this lesson, I discuss why programmes that are created through a machine-learning process, are radically different to programmes that have been developed in the classical or traditional way. Machine learning turns classical software development on its head. In this lesson, you'll begin to understand why.

In this lesson, I go into more detail about how machine learning completely turns the classical software development process on its head. And to effectively illustrate this, I start touching on some of the mathematics that replaces conventional programming code.

In this lesson, I go a bit further with the mathematics and function-approximation concepts behind machine learning. This is necessary because it paves the way toward understanding the role that neural networks play in Machine Learning. So, I touch on artificial neural networks in this lesson as well. I also introduce the concepts of encoding and decoding between numeric and non-numeric data such categorical or image data. Machines and Mathematics work with numbers. The ability to encode non-numeric data into something that a machine can understand is therefore a crucial concept to understand.

In this lesson, I discuss the 3 main machine learning techniques. These are Supervised, Unsupervised and Reinforcement Learning techniques. And to clearly explain the differences between these learning techniques, I carefully introduce important and fundamental concepts such as algorithms, models, features, labels, reinforcement learning agents, and rewards.

In this lesson, I discuss Deep Learning, Deep Neural Networks and mathematical function approximation. This lesson focusses on how neural networks can approximate the functions and models used by AI systems. But it does not cover the training of the neural network. Those are advanced topics for future lessons.

This worked sequence builds on the neural-network foundations and complements the course's later training-theory topics. High-school mathematics and basic matrix multiplication are enough; no programming or advanced mathematics is assumed.

How does a neural network discover better weights and biases? We begin with the complete training loop so every calculation that follows has a clear purpose. A small visual example connects prediction, error measurement, gradients and parameter updates. This gives us a practical roadmap for understanding neural network training, using familiar arithmetic and explanations that build each new idea before introducing its technical name.

By the end of this lecture, we can:

• Identify the five stages: predict, measure, trace, adjust and repeat.

• Explain why calculating a prediction alone does not train the network.

• Describe how gradients help guide changes to weights and biases.

Before we investigate learning, we need to understand the small network doing the calculations. We meet its two inputs, two hidden neurons and single output, then locate the six weights and three biases that training can adjust. A simple graph makes the ReLU activation function concrete: negative inputs become zero, while positive inputs pass through. This shared example keeps the later mathematics connected to a visible mechanism.

By the end of this lecture, we can:

• Locate the inputs, hidden layer and output.

• Explain the roles of weights and biases.

• Apply ReLU to positive and negative weighted sums.

We follow one labelled example through the network and calculate its first prediction. Each multiplication, addition and ReLU operation contributes to a result we can inspect. Keeping the known target separate from the prediction helps explain what the network receives and what it must learn to produce. The forward-pass animation also makes an essential distinction visible: information moves through the network while its weights and biases remain fixed.

By the end of this lecture, we can:

• Calculate the hidden-neuron outputs and final prediction.

• Distinguish the prediction from the target.

• Explain why a forward pass alone does not update parameters.

A prediction can be wrong by different amounts, so training needs a numerical way to compare results. We build the half-squared-error loss from the difference between our prediction and target, explaining each arithmetic step before introducing the compact formula. We also examine why the error is squared and why multiplying by one half changes the scale without changing which prediction has the smaller squared error. This creates the objective our training updates will try to reduce.

By the end of this lecture, we can:

• Calculate the half-squared-error loss.

• Explain why squaring the prediction error is useful.

• Describe the purpose of the one-half factor.

With nine adjustable parameters, how can we decide which change might help? We begin by nudging one output weight and observing the resulting change in prediction and loss. Progressively smaller nudges reveal the local slope of the loss curve. This builds the meaning of a derivative from a measurable experiment, connecting the graph, the arithmetic and the training question before relying on calculus notation.

By the end of this lecture, we can:

• Measure how loss changes when one weight changes.

• Calculate a change-in-loss divided by change-in-weight ratio.

• Explain how smaller nudges reveal a derivative as a local sensitivity.

A derivative becomes useful for training when we can interpret its sign. We examine how positive and negative slopes suggest different small weight changes, then clarify what stays fixed when we take a partial derivative. The other parameters remain unchanged, while downstream calculations can still respond. Finally, we bring the individual parameter sensitivities together into a gradient, giving us an organised description of how the loss responds to the network's settings.

By the end of this lecture, we can:

• Use a derivative's sign to identify a locally helpful change.

• Explain what a partial derivative holds fixed.

• Describe a gradient as a collection of parameter sensitivities.

To understand a weight's effect on loss, we first need the final link: how changing the prediction changes the loss. We return to the training-loop roadmap, then use small prediction changes to uncover this sensitivity. The graph now shows loss against prediction, making it distinct from the earlier weight-versus-loss graph. The calculation also reveals why the one-half factor in our loss function makes the derivative particularly convenient.

By the end of this lecture, we can:

• Locate sensitivity calculation within the training loop.

• Calculate the loss's sensitivity to the prediction.

• Explain how the one-half factor simplifies the squared-error derivative.

Can we calculate a weight's sensitivity without repeatedly nudging it? We connect two local effects: how the output weight changes the prediction, and how the prediction changes the loss. Multiplying those sensitivities gives the output weight's gradient directly. We then compare the result with the earlier small-change experiments, showing how the arithmetic and the graphical intuition describe the same local behaviour in our example network.

By the end of this lecture, we can:

• Identify the two links between an output weight and the loss.

• Calculate the output weight's gradient from local sensitivities.

• Explain why the result matches the limiting small-nudge estimate.

An earlier weight influences the loss through several calculations. We follow a small change through a hidden neuron's weighted sum, its ReLU activation, the final prediction and the loss. A visible path through the original network keeps each step connected to the architecture. By separating actual values from local sensitivities, we prepare to combine those sensitivities without confusing a neuron's output with the effect of changing that output.

By the end of this lecture, we can:

• Trace an earlier weight's influence through the network.

• Identify the local multiplier at each link.

• Explain ReLU's contribution along the positive part of the example path.

We now turn the linked effects along a network path into a single gradient. The numerical calculation comes first, followed by the chain-rule notation that expresses the same reasoning. Comparing two earlier weights shows why different parameters can receive different gradients even when much of their path to the loss is shared. This makes the chain rule a practical tool for understanding neural network training, with every factor tied to a familiar calculation.

By the end of this lecture, we can:

• Calculate an earlier weight's gradient by multiplying local sensitivities.

• Match chain-rule symbols to the corresponding network operations.

• Explain why different input weights can have different gradients.

Calculating every parameter's gradient separately would repeat many of the same downstream calculations. We identify that repeated work, then start from the loss and reuse shared sensitivities as we move backward. This reveals why backpropagation is organised in reverse and how it produces gradients for all six weights and three biases. Throughout the calculation, we distinguish sensitivities from parameter values: the gradients provide information for an update, but the network's settings have not changed yet.

By the end of this lecture, we can:

• Identify shared calculations that backpropagation reuses.

• Trace backward sensitivities into weight and bias gradients.

• Distinguish gradient calculation from parameter updates.

Gradients tell us how sensitive the loss is; an optimizer turns that information into parameter changes. We apply gradient descent using a learning rate, update all nine parameters from the same original network state, and immediately run another forward pass. The improved prediction and lower loss make our first complete learning step visible. We also distinguish learned parameters from the learning-rate hyperparameter that controls the scale of their updates.

By the end of this lecture, we can:

• Apply the gradient-descent update rule to weights and biases.

• Explain why the update uses gradients calculated at the same parameter values.

• Compare the prediction and loss before and after the update.

A helpful direction is only part of a useful update: the step size matters too. We compare three learning rates on the same one-weight loss curve, resetting the starting point and holding the other parameters fixed. Small steps make slow progress, a suitable rate moves efficiently, and an excessive rate overshoots. Recalculating the gradient after each step also explains why updates can shrink even when the learning rate stays constant.

By the end of this lecture, we can:

• Compare slow progress, steady progress and overshooting.

• Explain why each update needs the current gradient.

• Explain why one learning rate cannot be assumed best for every problem.

One update is a beginning. We return to the full network and repeat prediction, loss calculation, backpropagation and parameter updates, watching the prediction move closer to its target. We then examine what that progress does and does not demonstrate. Fitting one example makes the training mechanism easy to inspect, but useful machine learning also requires suitable data and evaluation on examples that were not used to adjust the parameters.

By the end of this lecture, we can:

• Trace several complete training cycles.

• Explain why predictions, losses and gradients are recalculated.

• Distinguish lower training loss from evidence of generalisation to unseen examples.

How does the reasoning from our small network scale to millions of parameters? We introduce computational graphs and automatic differentiation, explaining how software combines derivative rules and reuses sensitivities. We also separate training from inference: using learned weights to produce a response does not, by itself, update those weights. These connections help us ask precise questions about larger neural networks and language models without needing to write code.

By the end of this lecture, we can:

• Explain how automatic differentiation calculates gradients from recorded operations.

• Distinguish derivative calculations from repeated small-nudge experiments.

• Distinguish training, inference and changes to a model's input.

The chain rule also helps explain why neural network training can become slow or unstable. We follow illustrative chains of local multipliers to see how a sensitivity can shrink dramatically or grow very large. Connecting those gradients to the update rule reveals their effect on earlier parameters. We also separate exploding gradients from overshooting caused by an excessive learning rate, and recognise that depth alone does not guarantee either problem.

By the end of this lecture, we can:

• Use repeated multiplication to explain vanishing and exploding gradients.

• Relate gradient magnitude to the size of parameter updates.

• Distinguish gradient amplification from an excessively large learning rate.

We bring the complete mechanism together and give every technical term a clear job. Predictions lead to a loss, backpropagation calculates gradients, and the optimizer uses those gradients to update parameters before the next cycle. Final questions test whether we can explain why the calculation runs backward, what backpropagation actually produces, and why a falling training loss is not enough to demonstrate useful predictions on new examples.

By the end of this lecture, we can:

• Explain the full neural network training loop in our own words.

• Distinguish the roles of the chain rule, backpropagation and optimizer.

• Explain why generalisation requires checking unseen examples.

In this lesson, we contrast traditional rule-based logic (If-Then-Else) with ML’s data-driven approaches. This lesson sets the stage by explaining why math underlies all of machine learning. Whether it is supervised or unsupervised learning, the “model” is a mathematical function being optimised. This lesson explains the basics of how the different supervised and unsupervised machine learning algorithms ‘fit a function to known data’, so that after it is ‘trained’ it can be used on new data. This is in stark contrast to traditional programming where we rely on hard-coded logic.

We introduce the concept of a model as a function that takes inputs (features) and produces predictions (regression, classification, etc.). We clarify what model parameters are, and how fitting a model means adjusting these parameters to better approximate the mapping between inputs and outputs. Additionally, we ensure a proper understanding of important concepts such as labelled data, algorithms, loss functions, overfitting and model performance evaluation.

We introduce the concept of a model not as a function that predicts outputs for inputs, but instead organizes data based on relationships between the data items. We clarify what model parameters are, and how ‘fitting a model’ means adjusting these parameters to better approximate the underlying data relationships. Additionally, we ensure proper understanding of important concepts such as unlabelled data, algorithms, loss functions, overfitting and model performance evaluation.

This lesson introduces fascinating real-world examples of where reinforcement learning (RL) is powering the most mind-blowing advancements of our time. This includes, but is not limited to robotics, game-playing agents, landing rockets, controlling nuclear fusion reactions, high-frequency algorithmic trading and advanced recommender systems (like Netflix or Instagram).

This lesson introduces the powerful role of reinforcement learning and AI-driven personalization in transforming recommendation systems across entertainment, e-commerce, and loyalty programs. By examining real-world examples from Netflix, Spotify, and leading retailers, it highlights how personalized recommendations significantly enhance customer engagement and business profitability.

This lesson outlines the fundamentals of traditional recommender systems, including collaborative filtering, matrix factorization, and content-based techniques. It explores how these methods evolved to address user preferences in loyalty and rewards programmes, paving the way for more advanced approaches.

Here, we introduce the core principles of reinforcement learning or RL, highlighting its focus on long-term outcomes and sequential decision-making. We show why RL is uniquely suited for loyalty programmes by discussing how it can continuously learn and adapt based on user interactions and feedback.

This lesson focuses on practical adoption, showcasing how leading companies have attempted to leverage RL in coalition reward programmes, credit card offers, and retail loyalty ecosystems. We discuss the tangible benefits, common pitfalls, and emerging trends in applying RL-based personalization strategies to drive sustained customer engagement.

This video introduces the speakers/specialists, Irlon and Eric. The high-level agenda/script is attached as a PDF. Irlon's responses to the questions outlined in the agenda are summarised in the attached PowerPoint presentation.

Build along with the Model Builder project companion in this lesson’s Resources. Download the four-page guide and the original project data ZIP, then extract the data files locally.

Follow Sections 9–12: orient in lectures 27–28, set up Visual Studio in 29–30, learn the workflow in 31–35, build the model in 36–39, and interpret/use it in 40–41. Use lesson titles if numbering changes.

Start training with insurance_train.csv. Keep insurance_test.csv aside for evaluation; it has no header. The full insurance.csv already includes those test rows, so do not use it for training if you intend to claim an unseen test.

The guide provides five checkpoints, troubleshooting, a results worksheet and a five-question interpretation check with explanations. Your goal is a saved model and an evidence-based explanation of its predictions, not a particular score. Use the current Microsoft setup links in the guide if your menus differ from the recording.

This lesson introduces ML.Net and Model Builder, the free graphical tool that we'll use to go through a supervised machine learning process, without the need for any coding. This lesson also outlines the approach that will be taken during the subsequent 13 lessons. It provides a visually detailed explanation of the major components and sequence of topics that will be covered.