Practical AI and Machine Learning with Model Builder AutoML

Optional refresher: use this lesson if the difference between rule-based software and machine learning is unfamiliar. Otherwise, continue to Visual Studio and Model Builder.

We compare writing task-specific rules with learning a useful relationship from examples. Both approaches still use programmed algorithms; machine learning changes how the task-specific behaviour is obtained.

By the end of this lecture, we can:

- Explain how learning from data differs from explicitly writing every decision rule.

- Identify features, labels and predictions in a simple example.

- Connect these ideas to the supervised Model Builder workflow.

Precision note: training does not always mean repeatedly adjusting numerical parameters; different algorithms learn in different ways.

Optional refresher: supervised learning provides the foundation for our Model Builder regression project. We distinguish numerical prediction from classification and examine how labelled examples guide learning and evaluation.

By the end of this lecture, we can:

- Distinguish regression from classification.

- Identify input features and target labels.

- Explain why a trained model must be evaluated on examples beyond those used to fit it.

Precision note: mean squared error is the average squared prediction error. It is not generally identical to the variance of the errors, and a low training error alone does not establish good performance on new data.

Optional background: unsupervised learning helps us recognise tasks that differ from the supervised regression project in this course. We explore discovering groups and useful structure when target labels are not supplied.

By the end of this lecture, we can:

- Distinguish supervised prediction from unsupervised pattern discovery.

- Explain the purpose of clustering and dimensionality reduction.

- Recognise that the task and available data determine which learning approach is appropriate.

Precision notes: unsupervised learning still involves human choices and produces outputs; it does not mean no human involvement. K-means seeks to reduce within-cluster squared distances, but its iterations do not guarantee the globally best clustering.

How can a machine learn which action to take when we cannot give it the correct answer for every situation? In this excerpt from my original narrated flagship lesson, we explore reinforcement learning through a jumping agent and Pac-Man. We connect actions and their consequences to numerical rewards and explain why reward design matters.

By the end of this lesson, we can:

• Identify the agent, environment, actions and rewards in a simple example.

• Explain how feedback from experience can improve an agent’s decisions.

• Distinguish predicting a known label from learning actions that improve cumulative reward.

• Explain why the rewards must align with the goal we actually want to achieve.

This is an optional conceptual refresher. The practical Model Builder project in this course uses supervised regression; this lesson does not add a reinforcement-learning workflow to Model Builder.

Precision note: reinforcement learning uses experience data. Online methods collect new interactions, while offline methods learn from previously collected experience. Reward feedback guides learning but does not guarantee that the best strategy will be discovered.

This video outlines how to download, install, and configure Visual Studio. If you already have Visual Studio running on your machine, you can configure it for Machine Learning in one of two ways:

1. Via the Visual Studio Installer, ensure that you have the correct workload. Alternatively,

2. Add the Model Builder Extension from inside Visual Studio.

This video shows you how to launch Visual Studio and create a basic class library project. In the next lesson, we'll add machine learning capability to this code library. This video also provides explanations about project templates, solutions, dynamically linked library files, and the .Net Framework. Once a project is created, this video provides a summary of the most important windows in the Visual Studio interface:

1. The Solution Explorer Window,

2. The Code Editor Window, and

3. The Output Window.

In this video, we are going to start with a very short, theoretical overview of the machine learning process. Thereafter, you will see how to easily add machine learning capability to the class library project that was created in the previous lesson. The Model Builder wizard will be started up, and you will be able to get a visual sense of how the Model Builder wizard automates most of the machine learning processes for you.

This video will show you what types of machine learning tasks Model Builder can automate for you. This video covers concepts like classification, regression, and recommendation-type tasks, that machine-learning models are ideally suited for. This video also provides a quick overview of the different computing resources (CPU, GPU, or Cloud) that can be configured for training a model.

We explore how to prepare data before model training, including categorical encoding and numerical feature scaling.

By the end of this lesson, we can distinguish features from the label, explain why categories need a suitable representation, and describe when different numerical scales can affect a model.

Study notes for a reliable experiment:

• Investigate missing values and unusual observations before choosing a treatment. Correct data errors, but do not automatically delete genuine rare cases that matter to the intended population.

• Encoding represents categories; scaling changes the numerical range or distribution of a feature. These solve different problems. Scaling matters for scale-sensitive methods; not every model requires it.

• Split data before fitting learned preprocessing. Learn imputation values, scaling statistics and other fitted transformations from the training portion only, then apply those fitted transformations to validation and test data. Repeat this within each training fold during cross-validation.

• Use only information that would be available when a real prediction is made. A feature derived from the answer or from future information can leak the target and give misleading evaluation results.

We connect training algorithms, trained models, hyperparameters and evaluation metrics within a supervised-learning experiment.

By the end of this lesson, we can distinguish an algorithm from the fitted model it produces; distinguish learned parameters from settings chosen for a training run; and explain why the evaluation metric must match the prediction task.

Precision note: AutoML explores candidate algorithms and settings within an available search budget. It returns a strong candidate among those it evaluated for the selected metric; it does not guarantee the best possible model or remove our responsibility for the problem, data and evaluation design.

An AutoML time budget limits the overall search. Early stopping is a different idea: it stops an individual training run according to a monitored performance measure and stopping rule, often using validation performance. More search time does not guarantee better performance on genuinely unseen data.

We examine how to judge a trained model, recognize underfitting and overfitting, and decide whether its predictions are useful beyond the training examples.

By the end of this lesson, we can distinguish training, validation and final testing; interpret regression metrics in context; and explain why good training performance alone does not establish generalization.

Training data is used to fit model parameters. Validation data, or appropriately designed cross-validation, supports model comparison, hyperparameter selection and stopping decisions. Keep a separate final test set untouched until those decisions are complete. Data repeatedly used to choose a model is serving a validation role, even if a tool or older recording calls it test data.

Evaluate overfitting by comparing performance on training data with suitable held-out data. An excellent training score alone proves neither overfitting nor successful generalization. Low performance on both training and validation data can indicate underfitting, but also warrants checking data quality and whether the features contain useful information.

RMSE measures the square-root of mean squared prediction error, in the same units as the target. R-squared compares squared errors with predicting the mean target value of the evaluation data; it is not a percentage of correct predictions and can be negative. Compare scores on the same appropriately held-out data and examine errors as well as a headline metric.

Cross-validation rotates which portion is held out to estimate performance more robustly. It does not automatically prevent data leakage: fit preprocessing within each training fold and respect time order or related groups when the task requires it. Regularization can reduce overfitting, but it is not a guarantee; select its strength using validation and check the final model separately.

Use these distinctions in the machine-learning fundamentals practice test, then revisit them during the practical demonstration.

A short concept checkpoint before the machine-learning fundamentals assessment. Distinguish training, validation and final testing; prevent common data-leakage mistakes; interpret RMSE and R-squared; and explain why AutoML still needs informed human judgment. These principles apply across tools and software versions.

This video outlines the approach that we'll take for the practical machine learning exercise that will take place in this and the following four lessons. Thereafter, it will show you where to find datasets for machine-learning purposes. It will show you where to find the particular dataset that we'll use to train our model. The features and labels in this dataset are explored, along with a very basic overview of the concept of Exploratory Data Analysis. Thereafter, we return to Visual Studio and Model Builder, where we'll load our training data.

This video covers how to load and configure training data within Model Builder. The distinction between model validation and model testing is explored in detail. The important concept of k-fold cross-validation and its use as a technique to mitigate overfitting is also discussed.

This lesson covers the different training options that you can choose from within Model Builder. This includes things like training time and evaluation metrics. The choice of evaluation metrics then leads to a more technical discussion of what it means for a model to be overfitted to training data. The importance of having the optimal evaluation metric for both the training and test data sets is emphasized.

In this video, you finally see the machine learning training process in action. Background processes such as cross-validation, early stopping, and regularization are discussed to explain how Model Builder mitigates overfitting. The trained model is used to predict labels, and some of the limitations of the Model Builder Evaluate GUI are covered.

We investigate why the model predicts some charges better than others and connect the target distribution to R-squared and RMSE.

By the end, we can interpret both metrics, compare candidates on the same held-out data, and inspect which cases contribute the largest errors.

Precision notes: R-squared is not a percentage of correct predictions or a probability. It compares squared errors with a mean-prediction reference on the evaluation data and can be negative. RMSE has the same units as the target and gives larger errors greater influence; it does not describe every individual prediction.

Always identify which data produced a score. A cross-validation score is held-out evaluation across folds, not simply training fit. Use validation for model selection and reserve a separate final test for evaluating the selected approach. An excellent training score alone establishes neither overfitting nor successful generalization.

Choosing a metric can influence which model we select; merely displaying or measuring a metric does not improve a model. See “Before the Practice Test: Reliable Model Evaluation” for the complete distinctions.

In this lesson, you will see how to consume your trained model in a console application. You will see how to run your console application inside Visual Studio to make a prediction based on the trained model it is consuming. Thereafter, we train another model using just a training subset of the original data. This model is then consumed in a separate console application. The auto-generated code for the new console application is then extended to test the model against a separate test data set and to determine the evaluation metric for the test data set. We are then able to conclude whether the trained model was overfitted to the training data or not.

This written summary concludes the core Model Builder regression project and connects it to the optional learning paths.

By the end, we can summarize the supervised-learning workflow, distinguish model-selection evidence from a final test, explain ordinary inference, and choose an appropriate next learning step.

Continue to the optional neural-network foundations and training sequence for deeper model intuition, or use the live generative-AI seminar as supplementary context. The attached original summary document remains available; the article includes the clarified evaluation terminology.

Optional foundation for the neural-network training sequence. We locate deep learning within machine learning, introduce neurons, connections and hidden layers, and distinguish network depth from width.

By the end, we can identify the main parts of a network diagram, explain what makes a network deep, and distinguish a model architecture from supervised, unsupervised or reinforcement learning methods.

These concepts describe neural networks; Model Builder can also train other types of models.

We refresh the idea of a mathematical function using graphs and the dimensions of a cone, then connect inputs and outputs to features, labels and predictions. This gives us a reason to think of a neural network as a function approximator.

By the end, we can interpret simple function notation, distinguish dependent and independent variables, and explain how learning a relationship from data supports prediction.

Precision note: universal approximation describes what a sufficiently capable network can represent under suitable conditions, such as approximating a continuous function on a bounded closed input domain. It does not guarantee that training finds the function or that predictions generalise to unseen data.

Starting with y = 1.2x + 1, we examine how a neuron combines inputs, weights and a bias. We then introduce ReLU, extend the example to multiple inputs, and combine neurons to represent more complex relationships.

By the end, we can identify weights, biases and activation functions, trace a simple neuron’s forward calculation, and explain why nonlinear activations are useful.

Next, begin How Neural Networks Learn: The Training Loop. That separate sequence explains how the parameters change during training; the forward calculation here shows how a network produces a prediction with its current parameters.

This optional deep dive explains neural-network training beneath the tools, using high-school mathematics and basic matrix multiplication. No programming or advanced mathematics is assumed. AutoML can select many kinds of models: not every Model Builder model is a neural network or uses backpropagation.

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.

This is the opening to a quarterly gathering of the Institute of Risk Managers in South Africa. At this forum, one of our instructors, Irlon Terblanche, was asked to discuss Generative AI and its potential implications for Risk Management Professionals. Even though the audio was enhanced to remove background noise and echo, it is not as good as we would have liked. We have attached the actual presentation to supplement the videos, and to help you get through the lessons.

If you don't see a video in this lesson yet, it is only because Udemy is still busy processing it for approval. It should be available soon.