Deepak Devegowda · YouTube · 4:59
This video introduces Leave-One-Out Cross-Validation (LOOCV) as a method for evaluating regression models on small datasets. It contrasts LOOCV with simply calculating the Sum of Squared Errors (SSE) on all training data, highlighting that in-sample SSE does not guarantee good generalization to new data. Using a six-point bivariate dataset and three models (linear, quadratic, piecewise), the video visually demonstrates the LOOCV process: iteratively holding out one point for testing, training on the remaining five, and calculating the Squared Error (SE) for the held-out point. This video visually demonstrates Leave-One-Out Cross-Validation (LOOCV) for regression model selection using a six-point dataset. It sequentially evaluates Linear, Quadratic, and Piecewise models by rotating a single test point through six folds, calculating the Squared Error (SE) for each iteration. The Average SE is then computed across all folds for each model. A summary comparison reveals the Quadratic model as the best fit with the lowest error (0.083). The presentation concludes by outlining LOOCV's key characteristics: its effectiveness for small datasets, its strong generalization capabilities, and its computational expense for large datasets, recommending k-fold cross-validation as an alternative in such cases. This video segment outlines the key characteristics of Leave-One-Out Cross-Validation (LOOCV). It defines LOOCV as a method where each data point is used exactly once as test data, making it ideal for small datasets. However, because it requires n model fits per candidate model, it becomes computationally expensive for large datasets. The segment concludes by recommending k-fold cross-validation (with or 10) as a more efficient alternative for larger datasets.
Use the learning inspector for key ideas and moments, or open the reading tabs for the complete notes.
Generated from the video's visuals and explanation; not verbatim speech.
The video begins by introducing the topic of model evaluation using Leave-One-Out Cross-Validation (LOOCV), specifically applied to a small bivariate dataset consisting of six data points. The narrator explains that with very few data points, it is challenging to traditionally split the data into separate training and testing sets.
To illustrate the evaluation process, three different regression models are introduced: a linear model, a quadratic polynomial, and a piecewise linear function. The video shows these models being fitted to all six data points simultaneously. The Sum of Squared Errors (SSE) is calculated for each model on the full dataset, yielding values of 3.150 for linear, 0.105 for quadratic, and 1.665 for piecewise.
However, the narrator points out a critical limitation: calculating SSE on the entire dataset only measures how well the models fit the training data (in-sample fit). It does not provide information about how well these models will generalize to new, unseen data. This highlights the need for a more robust validation technique like LOOCV.
The video then transitions to demonstrating Leave-One-Out Cross-Validation. For Fold 1 of 6, the first data point is held out as the test set (highlighted in red), while the remaining five points serve as the training set (highlighted in blue). The three models are refitted exclusively to these five training points.
After fitting the models to the training data, their predictions are evaluated against the single held-out test point. The squared error (SE) is calculated for each model based on the residual at this test point, resulting in SE values of 4.886 for linear, 0.274 for quadratic, and 13.870 for piecewise. These values are kept aside.
The LOOCV process is then repeated for Fold 2 of 6. The second data point is now chosen as the test set, and the other five points form the training set. The models are refitted to this new training subset, and their performance is again evaluated against the newly held-out test point, generating a new set of squared errors.
The demonstration continues with Fold , where the third data point becomes the sole test sample. The linear, quadratic, and piecewise models are retrained on the remaining five points, yielding new squared errors of 1.052, 0.002, and 0.314 respectively.
Moving to Fold , the fourth point is held out for testing. The models adapt to the new training subset, producing squared errors of 0.414 for the linear fit, 0.123 for the quadratic curve, and 1.080 for the piecewise function.
In Fold , the fifth data point serves as the test case. The recalculated squared errors are 0.103, 0.032, and 0.235 for the respective models, illustrating how sensitive each functional form is to different regions of the data distribution.
After completing all six folds for the linear model, the individual squared errors are aggregated to compute an Average SE of 1.724. This metric summarizes the linear model's overall out-of-sample predictive accuracy across the entire dataset.
Similarly, the quadratic polynomial model completes its six-fold evaluation, resulting in an Average SE of 0.083. The piecewise linear function follows, yielding a significantly higher Average SE of 3.577, indicating poor generalization for this specific dataset.
By directly comparing the three Average SE values, the quadratic model emerges as the superior choice. Its minimal error of 0.083 demonstrates that it captures the underlying data structure more effectively than both the simpler linear and the more rigid piecewise alternatives.
The session concludes by formalizing the theoretical underpinnings of LOOCV. It is confirmed as an optimal strategy for small datasets where maximizing training data is critical, though its requirement for n model fits renders it impractical for large-scale problems, necessitating k-fold alternatives.
The lecture begins by reviewing a previous example involving a dataset with six data points. To evaluate models using Leave-One-Out Cross-Validation (LOOCV), each of the six points must serve as the test set exactly once. This means fitting each candidate model six separate times.
The speaker lists three specific candidate models from the example: linear fits, quadratic polynomials, and piecewise linear functions. Because each of the three models requires six fits, selecting the best model among them demands a total of 18 model fits. The speaker notes that real-world scenarios often involve evaluating even more models (e.g., six or seven) on more complex datasets.
Consequently, the cumulative computational cost of performing n fits for every candidate model makes LOOCV highly expensive for very large datasets. The segment concludes with the practical guideline that LOOCV is best suited for small datasets where data is precious, whereas k-fold cross-validation (typically with or 10) is the preferred method for larger datasets to manage computational load.
A resampling method used to evaluate machine learning models, particularly useful for small datasets. It involves splitting the dataset into n subsets, where n is the number of observations. Each subset is used exactly once as the validation data, while the remaining n-1 subsets are used for training. The model is trained and evaluated n times, and the results are averaged to produce a single estimation.
A measure of the discrepancy between a model's predictions and the actual observed values in the training dataset. It is calculated by summing the squares of the individual residuals. While useful for assessing in-sample fit, a low SSE does not guarantee good generalization to new data, as the model might be overfitting.
In the context of LOOCV, this is the squared difference between the actual value of the single held-out test point and the value predicted by the model trained on the remaining data. It directly measures the model's error on unseen data for that specific fold.
Evaluating a model solely on the data it was trained on (in-sample) can lead to overly optimistic performance estimates. Models, especially complex ones like high-degree polynomials or piecewise functions, can memorize the training data (overfitting) resulting in a very low SSE, but fail to capture the underlying pattern, leading to poor performance on new data.
LOOCV is a resampling method where the model is trained on n-1 data points and tested on the single remaining point. This cycle repeats n times so every observation serves as the test set exactly once, providing a robust estimate of out-of-sample performance without requiring a separate validation split.
For each LOOCV fold, the squared error quantifies the prediction mistake on the held-out test point. It is calculated as the square of the difference between the actual observed value and the value predicted by the model trained on the complementary subset of data.
Once all n folds are completed for a given model, the individual squared errors are averaged to produce a single scalar metric. This Average SE represents the model's expected prediction error on unseen data and serves as the primary basis for comparing different candidate models.
When evaluating multiple regression models, the one with the lowest Average SE from LOOCV is selected as the best fit. In the demonstrated example, the quadratic model achieved an Average SE of 0.083, substantially outperforming the linear (1.724) and piecewise (3.577) models.
LOOCV is ideal for small datasets because it utilizes nearly all available data for training in each fold, reducing bias in error estimation. However, requiring n separate model fits makes it computationally prohibitive for large datasets, where k-fold cross-validation with or 10 is the standard efficient alternative.
LOOCV is a resampling technique where each observation in the dataset is used exactly once as the validation data. Because it maximizes the training data size for each fold, it is highly suitable for small datasets where every data point is valuable.
Evaluating a single model using LOOCV requires fitting the model n times, where n is the number of data points. When comparing m candidate models, the total computational effort scales to model fits, making it prohibitively expensive for large datasets.
For larger datasets, k-fold cross-validation is recommended over LOOCV to reduce computational expense. By dividing the data into k subsets (commonly or 10), it requires only k model fits per candidate model, offering a much more efficient evaluation process.
Explore conditions, steps and evidence. Supplementary explanations are labeled separately from content shown in the video.
The text 'SSE = 3.150', 'SSE = 0.105', and 'SSE = 1.665' appears below the three respective plots.
SSE
Sum of Squared Errors
Non-negative real number
The text 'SE = 4.886', 'SE = 0.274', and 'SE = 13.870' appears below the three respective plots for Fold .
The text 'SE = 0.309', 'SE = 0.066', and 'SE = 0.481' appears below the three respective plots for Fold .
SE
Squared Error for a single test point
Non-negative real number
The label 'SE =' appears below each of the three plots in every fold, followed by a numeric value.
SE
Squared error for the current fold and model.
Non-negative real number.
The text 'Average SE =' appears at the bottom of the screen after the six folds for each model are displayed.
Average SE
The average squared error across all six folds for a specific model.
Non-negative real number.
The text 'Fold ' appears at the top of the screen, where k ranges from 2 to 5.
k
The index of the current data point being used as test data.
Integer from 1 to 6.
The speaker states, 'if we have six data points we're going to be doing six model evaluations'.
n
The total number of data points in the dataset.
Positive integer.
Point 3 states 'n model fits required'.
n
Number of data points in the dataset.
Positive integer.
Point 4 states 'use k-fold CV ( or 10)'.
k
Number of folds used in k-fold cross-validation.
Integer, typically 5 or 10 for larger datasets.
Speaker explains selecting five out of six points for training and one for testing, then repeating the process for other data points.
Animation shows different points being highlighted in red as test data while the rest remain blue as training data across multiple folds.
A model evaluation technique where the model is trained on all but one data point, and the remaining single point is used for testing. This process is repeated so that each data point serves as the test set exactly once.
Applicable when the dataset is small.
Requires fitting the model n times for n data points.
Speaker mentions calculating the sum of squared errors if all data is fit without evaluation.
SSE values are displayed for each model fitted to the entire dataset.
The sum of the squares of the differences between the observed dependent variables and those predicted by the regression model, calculated over the entire training dataset.
Calculated using all available data points.
Does not account for model generalization to new data.
Speaker states evaluating fits against test data and coming up with the squared error using residuals.
SE values are displayed for each model based on the single held-out test point.
The square of the difference between the actual value of the held-out test point and the value predicted by the model trained on the remaining data.
Calculated for a single held-out test point.
Used to evaluate model performance on unseen data.
The speaker explains repeating the process with the third, fourth, and fifth data points being the test data, while the remaining points are training data.
The animation shows a different single red dot becoming the test point in each successive fold, while the other five cyan dots serve as training data.
In Leave-One-Out Cross-Validation (LOOCV), the model is trained on all but one data point, and the remaining single data point is used as the test set. This process is repeated so that each data point serves as the test set exactly once.
The dataset must have a finite number of data points, n.
Each iteration uses n-1 points for training and 1 point for testing.
The label 'SE = [value]' is displayed below each plot.
The speaker mentions getting a 'squared error' for each fold.
The squared error measures the discrepancy between the predicted value from the fitted model and the actual observed value of the test data point.
Requires a fitted model and a held-out test data point.
The text 'Average SE = [value]' is displayed after showing all six folds for a given model.
The speaker states, 'the average squared error over all of these six folds is computed'.
After computing the squared error for each individual fold, the average squared error is calculated across all folds to provide a single performance metric for the model.
All n folds of the LOOCV must be completed.
A summary slide lists the Average SE for Linear, Quadratic, and Piecewise models.
The speaker says, 'Now we make a comparison between each one of these three models in terms of their average squared errors'.
Different regression models can be compared by evaluating their Average Squared Error using LOOCV. The model with the lowest average error is considered the best fit for generalizing to new data.
Multiple candidate models must be evaluated using the same dataset and LOOCV procedure.
Text on screen reads: 'Best for small datasets where data is precious' and 'Computationally expensive for larger datasets: n model fits required'.
The speaker notes it is used for small datasets and gets computationally expensive for very large datasets.
LOOCV is highly effective for small datasets because it maximizes the use of available training data in each fold. However, its requirement to fit the model n times makes it computationally expensive for large datasets.
Dataset size n is typically small.
Computational resources allow for n model fits.
Point 1 states 'LOOCV uses each data point exactly once as test data'.
Leave-One-Out Cross-Validation (LOOCV) is a resampling procedure where each observation in the dataset is used exactly once as the validation (test) data, while the remaining observations form the training set.
Applicable to any dataset size, but primarily recommended for small datasets.
Point 3 states 'Computationally expensive for larger datasets: n model fits required'.
The speaker explains that for 6 data points and 3 models, 18 different model fits are required.
For a dataset with n data points, evaluating a single model using LOOCV requires fitting the model n times. If there are m candidate models to choose from, the total number of model fits required is .
n is the number of data points.
m is the number of candidate models being evaluated.
Point 4 states 'For larger datasets, use k-fold CV ( or 10)'.
The speaker concludes that if you have large datasets, it's best to use k-fold cross-validation.
k-fold Cross-Validation is an alternative resampling method recommended for larger datasets to reduce computational cost. It divides the data into k subsets (folds), typically or 10, requiring only k model fits per candidate model instead of n.
Recommended when the dataset size n is large.
Typical values for k are 5 or 10.
The speaker concludes, 'We can see that the quadratic polynomial gives the best fit across each one of the six different test data points'.
The summary slide shows Quadratic Average SE = 0.083, which is lower than Linear (1.724) and Piecewise (3.577).
For the given dataset of six points, the quadratic polynomial model provides the best fit based on the lowest average squared error in LOOCV.
The dataset consists of six specific data points.
The models evaluated are linear, quadratic, and piecewise linear.
The evaluation metric is the average squared error from LOOCV.
Existential quantifier applied to the set of three models.
The speaker states, 'it's a model that fits the data well and generalizes to new data too'.
A model selected via LOOCV with a low average squared error is expected to generalize well to new, unseen data.
The model was evaluated using LOOCV.
The average squared error is low relative to other candidate models.
Universal quantifier implied for models satisfying the hypotheses.
Text on screen reads: 'For larger datasets, use k-fold CV ( or 10)'.
For larger datasets where LOOCV is computationally prohibitive, k-fold cross-validation with or should be used instead.
The dataset is large.
Computational efficiency is a concern.
Conditional statement.
Narrator describes the step-by-step process of LOOCV.
Visuals demonstrate the splitting of data into train/test sets, fitting models, and calculating SE for multiple folds.
Select n-1 data points for training and 1 data point for testing.
Stated by speaker and shown by highlighting 5 blue points and 1 red point.
Fit the candidate models (Linear, Quadratic, Piecewise) to the training data.
Curves are drawn through the blue training points.
Evaluate the fitted models against the single test data point to calculate the Squared Error (SE).
Vertical dashed lines show the residual from the test point to the curve, and SE values are displayed.
Repeat the process for each of the n data points serving as the test set.
Speaker says 'we repeat this exercise for the other data points' and animation transitions to Fold .
LOOCV systematically evaluates model generalization by cycling through all possible single-point test sets.
The video sequentially demonstrates Fold through Fold , showing the test point changing and the SE updating for each model.
Individual SE values are shown for each fold, followed by an 'Average SE' calculation for each model type.
Iterate through each of the n data points.
Definition of Leave-One-Out Cross-Validation.
Fit the chosen regression model using the remaining n-1 data points as training data.
LOOCV methodology.
Calculate the squared error using the held-out point as the test data.
Definition of squared error metric.
Compute the mean of all individual squared errors to get the final performance score for the model.
Aggregation step in cross-validation.
The Average SE provides a robust estimate of the model's out-of-sample error.
Speaker lists three different models: linear, quadratic polynomial, and piecewise linear function.
Three side-by-side plots show the data points fitted with a red line, a yellow parabola, and a cyan piecewise line, respectively.
Fit three different models to a bivariate dataset of six points and calculate their Sum of Squared Errors (SSE).
Bivariate dataset with 6 data points.
Three models: Linear, Quadratic, Piecewise.
Calculate SSE for each model when fitted to all data.
Fit a linear model to all 6 points.
Red straight line is drawn through the points.
Fit a quadratic model to all 6 points.
Yellow parabolic curve is drawn through the points.
Fit a piecewise linear model to all 6 points.
Cyan connected line segments are drawn through the points.
Calculate SSE for the linear model.
Displayed on screen below the linear plot.
Calculate SSE for the quadratic model.
Displayed on screen below the quadratic plot.
Calculate SSE for the piecewise model.
Displayed on screen below the piecewise plot.
SSE values are 3.150 (Linear), 0.105 (Quadratic), and 1.665 (Piecewise).
Visual inspection of the curves passing through the points confirms the low SSE for the quadratic model which fits the points almost perfectly.
The entire video visualizes the LOOCV process on a fixed set of six cyan data points plotted on a 2D Cartesian coordinate system.
Specific numerical values for SE and Average SE are displayed for Linear, Quadratic, and Piecewise models.
The exact coordinates of the six data points are not explicitly stated in text or audio, only shown visually.
Evaluate and compare three regression models (Linear, Quadratic, Piecewise) on a dataset of six points using Leave-One-Out Cross-Validation.
A dataset containing exactly six data points.
Three candidate models: Linear, Quadratic, and Piecewise linear.
Determine which model has the lowest Average Squared Error and thus provides the best fit.
Train the linear model 6 times, leaving out one point each time, and calculate the SE for each fold.
Application of the LOOCV method.
The average of the six squared errors for the linear model is computed and displayed.
Aggregation of fold results.
Repeat the LOOCV process for the quadratic polynomial model.
Application of the LOOCV method to a second model.
The average squared error for the quadratic model is calculated.
Aggregation of fold results.
Repeat the LOOCV process for the piecewise linear function.
Application of the LOOCV method to a third model.
The average squared error for the piecewise model is calculated.
Aggregation of fold results.
Compare the three average squared errors to find the minimum value.
Model selection criterion based on lowest error.
The Quadratic model is the best fit with an Average SE of 0.083.
The summary slide at 01:18 explicitly lists the Average SE for all three models, confirming the quadratic model has the lowest value.
Speaker states: 'we had six data points... fit six different linear fits, six different quadratic polynomials, and six different piecewise linear functions... we had to do eighteen different model fits.'
Determine the total number of model fits required to select the best model among three candidates using LOOCV on a dataset with 6 data points.
Number of data points .
Number of candidate models (linear, quadratic, piecewise linear).
Calculate the total number of model fits.
Identify the number of fits required for a single model using LOOCV, which equals the number of data points ().
Definition of LOOCV requires leaving out one data point at a time.
Multiply the number of fits per model by the total number of candidate models (6 fits/model * 3 models).
Each of the 3 candidate models must be fully evaluated using LOOCV.
18 different model fits.
.
Six yellow data points appear sequentially on a 2D Cartesian coordinate system.
2D Cartesian axes
Six yellow data points
Data points appear one by one.
Coordinate system remains static.
Establishes the small bivariate dataset used for the demonstration.
Screen clears, text changes from 'Fold ' to 'Fold ', and a different point is highlighted in red while others are blue.
Text labels 'Fold ', 'Fold '
Data points colored red and blue
Test point changes from the first point to the second point.
Training points update accordingly.
Models are refitted and new SE values are calculated.
The underlying dataset of 6 points remains the same.
The three model types remain the same.
Demonstrates the iterative nature of Leave-One-Out Cross-Validation.
The screen transitions between Fold , Fold , Fold , and Fold . In each transition, a different single dot turns red (test data) while the others remain cyan (training data).
Six data points (cyan and red)
Three coordinate planes
Fitted curves (red line, green parabola, blue piecewise function)
SE labels
The identity of the red test point changes with each fold.
The fitted curves update to reflect training on the new subset of five points.
The SE values recalculate based on the new test point.
The total number of data points remains six.
The three model types being evaluated remain constant.
The coordinate system axes remain fixed.
Visually demonstrates the core mechanism of LOOCV: systematically rotating the single held-out test point while retraining the models on the remaining data.
A black screen displays white text summarizing the results: 'LOOCV Results Summary', followed by the Average SE for Linear, Quadratic, and Piecewise models.
Text labels for models
Numerical values for Average SE
None; this is a static display of aggregated results.
The three specific Average SE values (1.724, 0.083, 3.577).
Provides a clear, quantitative comparison of the three models' performance under the LOOCV framework, enabling immediate identification of the best-performing model.
A slide titled 'Key Points: Leave-One-Out Cross-Validation' appears, listing four bullet points about the method's definition, applicability, limitations, and alternatives.
Title text
Four numbered bullet points
None; static text display.
The four key takeaways about LOOCV.
Consolidates the theoretical understanding of LOOCV, highlighting its procedural definition, ideal use cases (small datasets), computational drawbacks (expensive for large n), and standard alternative (k-fold CV).
A static presentation slide titled 'Key Points: Leave-One-Out Cross-Validation' with four numbered bullet points summarizing the method, its ideal use case, its computational cost, and an alternative for larger datasets.
Title text
Four numbered bullet points
Footer text indicating course and instructor
The slide remains completely static throughout the 59-second clip.
The visual serves as a structured summary of the key theoretical and practical points of Leave-One-Out Cross-Validation, reinforcing the audio lecture.
Speaker states that calculating SSE on all data is 'not enough because we really don't know how well these models will generalize to new data.'
A low Sum of Squared Errors (SSE) on the training data guarantees a good model for new, unseen data.
SSE on the full dataset only measures in-sample fit. It does not account for overfitting or how well the model will generalize, which is why techniques like LOOCV are necessary.
Text states: 'Computationally expensive for larger datasets: n model fits required' and 'For larger datasets, use k-fold CV ( or 10)'.
Speaker notes it gets computationally expensive when you have very large datasets.
LOOCV is universally applicable and efficient regardless of dataset size.
LOOCV requires fitting the model n times, making it computationally prohibitive for large datasets. K-fold cross-validation (e.g., or 10) is the preferred alternative for larger data.
Speaker links evaluating against test data to coming up with the squared error.
LOOCV applies the calculation of Squared Error (SE) to a single held-out test point to measure generalization.
SSE is shown for the full dataset, while SE is shown for single test points in LOOCV.
SSE aggregates errors over the entire training set, whereas SE in LOOCV isolates the error on a single unseen test point to evaluate generalization.
Speaker connects the completion of six folds to the computation of the average squared error.
The calculation of the Average Squared Error strictly depends on first executing the full Leave-One-Out Cross-Validation procedure across all n folds.
Speaker uses the computed average squared errors to make a comparison between the three models.
The Average Squared Error metric is directly applied as the criterion for comparing and selecting the best regression model.
Text explicitly links LOOCV to being 'Best for small datasets'.
The definition and operational characteristics of the LOOCV method inherently contain the condition that it is best suited for small datasets due to its training data utilization strategy.
Point 3 notes LOOCV is computationally expensive for larger datasets, and Point 4 suggests using k-fold CV for larger datasets.
k-fold Cross-Validation is presented as a computationally cheaper alternative to LOOCV specifically for larger datasets.
Speaker explains the challenge of separating small datasets into train/test sets and the inadequacy of simple SSE.
Speaker details the process of selecting 5 training and 1 test point, then repeating.
Visuals show the folding process.
Speaker describes using each data point as test data sequentially.
Summary slide shows Quadratic has lowest Average SE.
Key points slide lists computational expense for large datasets.
Speaker mentions computing the average squared error over all six folds.
Discussion on why LOOCV is computationally expensive.
Point 4 recommends k-fold CV for larger datasets.
Covered · Introduction and display of the 6-point dataset.
Covered · Fitting three models to all data, calculating SSE, and explaining its limitation for generalization.
Covered · Introduction and execution of Fold of Leave-One-Out Cross-Validation.
Covered · Execution of Fold of Leave-One-Out Cross-Validation.
Covered · Demonstration of LOOCV folds 2 through 5, showing test point rotation and individual SE calculation.
Covered · Completion of all six folds for each model and computation of the Average Squared Error.
Covered · Comparison of the three models based on their Average SE, identifying the quadratic model as the best fit.
Covered · Summary of key theoretical points regarding LOOCV's applicability, generalization power, and computational limitations.
Covered · The entire 59-second clip consists of a static slide and continuous audio narration explaining the key points of LOOCV, its computational cost, and alternatives.
Reviewed English material v1: example/example "Comparing Regression Models on Full Dataset" from 0:25 to 0:54 — Fit three different models to a bivariate dataset of six points and calculate their Sum of Squared Errors (SSE). Calculate SSE for each model when fitted to all data. Fit a linear model to all 6 points.; Fit a quadratic model to all 6 points.; Fit a piecewise linear model to all 6 points.; Calculate SSE for the linear model.; Calculate SSE for the quadratic model.; Calculate SSE for the piecewise model.
Reviewed English material v1: card/concept_card "Leave-One-Out Cross-Validation (LOOCV)" starting at 0:55 — A resampling method used to evaluate machine learning models, particularly useful for small datasets. It involves splitting the dataset into n subsets, where n is the number of observations. Each subset is used exactly once as the validation data, while the remaining n-1 subsets are used for training. The model is trained and evaluated n times, and the results are averaged to produce a single estimation.
YouTube7:04Another application of Regression modeling.
Regression modeling
YouTube9:14Another explanation of Cross-validation.
Cross-validation
YouTube5:48Another application of Regression modeling.
Regression modeling
YouTube3:54Next in Mathematical modeling: Regression modeling → Least squares and residual diagnostics.
Least squares and residual diagnostics · View learning sequence
YouTube3:07Next in Mathematical modeling: Regression modeling → Least squares and residual diagnostics.
Least squares and residual diagnostics · View learning sequence
YouTube8:04Next in Mathematical modeling: Regression modeling → Least squares and residual diagnostics.
Least squares and residual diagnostics · View learning sequence
YouTube7:31Explanation of Regression modeling, complementing the current application.
Regression modelingYouTube3:54Explanation of Regression modeling, complementing the current application.
Regression modelingYouTube7:04Whiteboard for Regression modeling, compared with the current visual explanation.
Regression modeling