Mahesh Huddar · YouTube · 9:14
This video segment introduces the foundational concepts of dataset partitioning in machine learning before discussing cross-validation. It first explains the basic Train-Test split, where data is divided into training and testing subsets. It then extends this to the Train-Test-Validation split, introducing a validation set for hyperparameter tuning. Finally, it highlights a critical limitation common to both fixed splitting methods: they introduce bias because the model is never trained or evaluated on the complete representation of the entire dataset, motivating the need for more robust techniques like cross-validation. This 120-second introductory lecture segment explains why cross-validation is used in machine learning and then introduces k-fold cross-validation with a concrete example. It first warns that a model can overfit the training data and fail on test or real-world data, then states that cross-validation reduces dependence on a particular train/test split. After listing four cross-validation types, the clip focuses on K-folds: divide the dataset into K folds, train K times, hold out one fold for testing while using the other K-1 folds for training, and average the K performance scores to obtain the final estimate. This 120-second clip explains K-fold cross validation with and then motivates stratified K-fold cross validation. First, the speaker shows that each of five iterations holds out one fold for testing and trains on the remaining four folds. Next, using a three-class example, the video points out a disadvantage of ordinary K-fold CV: some folds do not contain equal representation of all classes, which the speaker says may lead to an overfitting state. Finally, the slide switches to StratifiedKFold, where each fold is constructed to preserve class representation, and the diagram shows testing portions split across multiple class regions in every iteration. A minor spoken inconsistency occurs when the narrator says “remaining five folds for training” despite the visible setup implying four training folds. This 120-second clip explains three cross-validation ideas in sequence. It first presents stratified k-fold cross validation as a way to keep each class equally represented across folds, using a chart with and mixed training/testing blocks by class. It then switches to leave-one-out cross validation, defining it as the extreme case of k-fold where 1 example is tested and n-1 are trained in each of n iterations, illustrated with a 100-example case and criticized as usually too slow for large real-world datasets. Finally, it introduces leave-p-out cross validation as the generalization that holds out p examples instead of 1, with a handwritten example , but the clip ends before the full leave-p-out explanation is completed. This segment explains Leave-P-out cross validation, detailing how P examples are randomly selected for testing in each iteration while the rest are used for training. It highlights that due to random selection, the same example may appear in the test set across multiple iterations.
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 opens with a title slide listing four types of Cross Validation: K-folds, Stratified K-folds, Leave-one-out, and Leave-p-out. An accompanying diagram illustrates Stratified K-fold sampling across five iterations, maintaining class proportions. This serves as a roadmap for the broader topic, though the current segment focuses on prerequisites.
To build intuition for cross-validation, the lecture starts with basic model building. A dataset is represented as a horizontal bar, which is partitioned into two disjoint subsets: a Training Set and a Test Set. The audio clarifies that the model learns parameters from the training data and is subsequently evaluated on the held-out test data to estimate generalization performance.
The concept is extended to address hyperparameter tuning. The original dataset is still split into Training and Test sets, but the Training Set is further subdivided into an inner Training Set and a Validation Set. A workflow diagram shows the model being trained on the inner training data, evaluated on the validation set, and iteratively tuned via a feedback loop. Only after satisfactory validation performance is achieved is the final model assessed on the isolated Test Set.
Despite their utility, both fixed splitting strategies share a fundamental limitation. Because the data is permanently assigned to specific roles (train, validate, or test), the model never interacts with the complete dataset representation during any single phase. This static partitioning introduces selection bias, as the evaluation depends heavily on the arbitrary initial split rather than the full data distribution. This drawback motivates the need for resampling techniques like cross-validation.
The segment opens on a workflow diagram for ordinary machine-learning evaluation. While the speaker discusses overfitting, the visual shows an original dataset split into training and test sets, and then a more elaborate split into training, validation, and test sets feeding a learning algorithm and predictive model. The key point is verbal: a model can fit the training data extremely well yet fail on testing or in real-world use.
The lecture then pivots to the remedy. A new slide titled “Cross Validation in Machine Learning” states that cross-validation arises because of problems with train-test or train-test-validation models, and that it aims to make the model score less dependent on the particular way the train and test sets were chosen. The speaker adds that in cross-validation the model is trained and tested using the entire dataset across the procedure.
Before defining the mechanism, the video lists four cross-validation families: K-folds, Stratified K-folds, Leave-one-out, and Leave-p-out. Only the first item is developed in this clip; the others are named as upcoming topics.
The main explanation is a schematic for 10-fold cross-validation. The dataset is divided into folds. Each row in the figure represents one iteration. In every row, exactly one fold is marked as Test and the remaining nine folds are marked as Training. The speaker walks through iteration (1), where the first fold is held out, and iteration (2), where the second fold is held out, then states that the same pattern continues through all ten iterations.
The clip closes by specifying how the multiple iteration results are combined: after the ten train/test rounds, their performances are averaged, and that average is taken as the final performance estimate of the model. A transition to another K-fold illustration begins at the very end, but no further complete idea is introduced within the provided 120 seconds.
The clip opens on a slide titled "K-folds Cross Validation in Machine Learning" with a chart labeled "KFold". The horizontal axis is "CV iteration" with values 1 through 5, and the legend distinguishes an orange/red "Testing set" from a blue "Training set". The narrator states that K is set to 5, meaning the dataset is divided into five folds.
The method is then described operationally: in each iteration, one fold is used for testing and the remaining folds are used for training. The visible diagram supports this with one orange/red block and four blue blocks in each of the five bars. There is a spoken slip when the narrator says "remaining five folds for training"; the intended meaning, confirmed by the figure and by the next sentence, is the remaining four folds.
The speaker walks through the first two iterations explicitly. In iteration 1, one fold is held out for testing while the other four are used for training. In iteration 2, a different fold becomes the testing set and the rest are used for training. The phrase "and so on" extends the same pattern to iterations 3, 4, and 5, matching the repeated one-test/four-train structure across the KFold chart.
The explanation then shifts to a limitation of ordinary K-fold CV. The leftmost column labeled "class" is treated as a three-class dataset, and handwritten labels 1, 2, and 3 are added to the three stacked class blocks. The narrator uses this labeling to inspect where the testing folds come from across the five iterations.
According to the spoken walkthrough, the testing fold in the first iteration comes from the third class, and the second iteration also draws from that same class region. Later iterations draw from the first and second classes instead. The key point is not the exact identity of each class but the pattern: the holdout folds are not guaranteed to contain balanced samples from all three classes.
From this observation, the narrator concludes that plain K-fold cross validation may fail to take equal representation of each class in every iteration. The clip further states that this imbalance can push the learning process into an "overfitting state". This is presented as a verbal warning rather than a formal proof; the mechanism is not elaborated within the excerpt.
To address that drawback, the slide changes to "Stratified K-folds Cross Validation in Machine Learning" with chart title "StratifiedKFold". The overall layout remains the same—five CV iterations, , orange/red for testing and blue for training—but the internal pattern of the bars changes. The narrator defines stratified K-fold as a partitioning scheme in which each fold has equal representation of the classes.
The first StratifiedKFold iteration is used to illustrate the idea. Instead of a single contiguous testing block, the testing portion appears as several small orange/red segments distributed across different class regions within the same bar. The speaker interprets this as the testing fold containing representation from each class. The same segmented pattern is then said to repeat in the second, third, and subsequent iterations.
The clip closes by restating the practical consequence of stratification: in every iteration, the testing set preserves representation from each class of the dataset. Thus the video contrasts ordinary K-fold CV, which can produce class-skewed folds, with stratified K-fold CV, which is designed to maintain class balance across folds.
The opening slide is titled “Stratified K-folds Cross Validation in Machine Learning,” and the chart itself is labeled “StratifiedKFold.” The y-axis is “Sample index,” while the x-axis shows one “class” column followed by five CV iteration columns labeled 1 through 5. Orange blocks denote the testing set and blue blocks denote the training set. A handwritten note marks .
The speaker’s point is that stratified k-fold addresses a weakness of ordinary k-fold by preserving equal representation of each class across folds. Visually, each iteration column contains a mixture of training and testing segments drawn from multiple class bands rather than isolating one class completely.
The next slide introduces “Leave-one-out Cross Validation in Machine Learning.” Four horizontal bars are labeled Iteration , Iteration , Iteration , and Iteration , with an ellipsis indicating continuation. Each bar contains one very narrow separated segment and a much larger remaining segment.
The narration frames leave-one-out as the extreme case of k-fold cross validation. To make that contrast explicit, the presenter writes while recalling that ordinary k-fold splits the data into k groups and trains k times.
The definition then becomes concrete: in each iteration, 1 example is used for testing and the remaining n - 1 examples are used for training. The slide’s repeated one-small-piece-per-row pattern visually encodes exactly that split.
From this definition, the number of iterations follows directly. If the dataset has n examples, then leave-one-out runs n times, once for each example serving as the test case.
The speaker instantiates the idea with 100 examples. In the first iteration, 1 example is held out for testing and 99 are used for training; the same pattern repeats 100 times. Handwritten annotations reinforce this with 100 and 1, 99.
The practical conclusion is that leave-one-out is rarely used in real-world settings because it requires one full model training per example. For datasets with 1000 or 10000 examples, that many trainings become too expensive, so ordinary k-fold is preferred instead.
The final slide introduces “Leave-P-out Cross Validation in Machine Learning.” Here the legend labels blue as train and red as test, and the printed caption reads “Leave p out.” The bars now contain multiple red test blocks rather than a single tiny holdout.
The speaker defines leave-p-out by changing only one parameter from leave-one-out: instead of testing on 1 example per iteration, each iteration tests on p examples. A handwritten example sets , indicating three held-out test examples per iteration.
The clip ends while the speaker is still elaborating on the example, so the basic definition is clear, but the fuller consequences of leave-p-out are not completed within this segment.
The speaker begins by explaining the core mechanism of Leave-P-out cross validation. In each iteration, a fixed number of examples, denoted as , are randomly selected to form the test set. The visual aid shows four rows of data blocks, with red representing 'test' and blue representing 'train'. The handwritten note '' clarifies that three examples are chosen for testing in each round.
The explanation continues by walking through the first few iterations. In the first iteration, three specific red blocks are marked as the test set, and the remaining blue blocks constitute the training set. The same logic applies to the second iteration, where a different random selection of three red blocks forms the new test set.
A key characteristic of this method is then highlighted. By examining the third iteration, the speaker points out that one of the examples selected for testing has already been part of the test set in the first iteration. This overlap occurs precisely because the selection of the test examples is done randomly in each independent iteration.
The speaker concludes the technical explanation by reiterating that this random selection process means there is always a possibility for the same data point to be included in the test set across multiple different iterations of the cross-validation procedure.
The video transitions to its conclusion. The speaker summarizes that the current video covered the definition of cross validation, its necessity, and various techniques including the one just demonstrated.
Finally, the speaker announces that the next video will focus on implementing these cross validation techniques using Python, directing viewers to a link in the description for further learning on building machine learning models.
The simplest method for evaluating machine learning models involves dividing the available dataset into two mutually exclusive subsets. The larger subset, the Training Set, is used to fit the model's parameters. The smaller subset, the Test Set, is withheld entirely during training and used only once at the end to provide an unbiased estimate of the model's performance on unseen data.
When hyperparameter tuning is necessary, a three-way split is used. The dataset is first divided into Training and Test sets. The Training set is then further split into a model-training subset and a Validation subset. The validation set guides hyperparameter selection and early stopping without contaminating the test set. The test set remains untouched until the final model configuration is locked in.
A critical limitation of both train-test and train-test-validation splits is that they rely on a single, static partition of the data. Since portions of the dataset are permanently excluded from training or evaluation phases, the resulting performance metrics can be biased by the specific samples assigned to each role. The model never leverages or is validated against the full representational capacity of the entire dataset, motivating resampling approaches like cross-validation.
The video defines overfitting informally as a state where a model works perfectly on training data but does not work on testing or in the real world. This is used as the problem that motivates cross-validation.
Cross-validation is introduced as a way to avoid difficulties caused by a single arbitrary train/test or train/validation/test split. The slide states that it wants the model score not to depend on the particular way the train and test set were picked.
The lecture lists K-folds, Stratified K-folds, Leave-one-out, and Leave-p-out as types of cross-validation. Within this clip, only K-fold cross-validation is explained in detail.
In k-fold cross-validation, the dataset is divided into K folds. The model is trained K times. In each iteration, one fold is used for testing and the remaining K-1 folds are used for training. The example shown uses , so each round has 1 test fold and 9 training folds.
After completing all K iterations, the performance values are averaged. That average is presented as the final performance of the model under k-fold cross-validation.
The video presents K-fold cross validation as a procedure that divides the dataset into K folds and runs K iterations. In this example , so there are five folds and five CV iterations. Each iteration holds out one fold as the testing set and uses the remaining folds as the training set. The KFold diagram makes this concrete by showing one orange/red testing block and four blue training blocks in each of the five bars.
For the illustrated case, the rule is: select one fold for testing and train on the other four folds. The narrator explicitly describes iteration 1 and iteration 2 in these terms and then generalizes to the remaining iterations. A spoken inconsistency says "remaining five folds for training," but the visible figure and the surrounding explanation confirm that only four folds remain for training when one of five is used for testing.
Using a three-class example, the clip shows that ordinary K-fold CV can produce folds whose class composition is uneven. The speaker points out that some testing folds come mostly from one class while later folds come from other classes. The central issue is that the holdout set in a given iteration need not reflect the class distribution of the full dataset.
After identifying unequal class representation across folds, the narrator states that this may cause the process to enter an "overfitting state." The excerpt does not prove this formally; it presents it as a practical warning that unbalanced validation folds can worsen model assessment and learning behavior.
Stratified K-fold CV is introduced as a fix for the class-imbalance problem. Rather than splitting the data without regard to class composition, the method partitions the dataset so that each fold contains equal representation of each class. In the StratifiedKFold figure, the testing portion in each iteration is broken into multiple small segments spread across different class regions, visually indicating that all classes are represented in the holdout set.
The StratifiedKFold slide keeps the same five-iteration structure and the same color coding as the KFold slide, but changes the internal pattern of each bar. Instead of one contiguous testing block, each iteration shows several orange/red testing fragments distributed across the class bands. The narrator interprets this as each fold preserving class balance, so every iteration gets representation from each class.
Stratified k-fold cross validation is introduced as a version of k-fold that keeps each class proportionally represented across folds. The slide shows five CV iterations with mixed orange testing and blue training blocks across class bands, and the speaker says this avoids the disadvantage of ordinary k-fold by ensuring equal representation of each class.
The video claims that stratified sampling across folds prevents bias and keeps the model from entering an overfitting state during evaluation. The reasoning given is that each class remains represented in both training and testing portions of every fold.
Leave-one-out cross validation is defined as the extreme case of k-fold cross validation. In each iteration, exactly 1 example is used for testing and the remaining n-1 examples are used for training.
If the dataset contains n examples, leave-one-out performs n iterations because each example must serve once as the held-out test case. The slide labels the rows from Iteration through Iteration to express this.
With 100 examples, the first iteration uses 1 example for testing and 99 for training. The same 1-versus-99 split is repeated across all 100 iterations, one for each example.
The speaker says leave-one-out is usually not used in real-world machine learning because it requires training the model once per example. For 1000 or 10000 examples, that many full trainings are typically infeasible, so k-fold is preferred.
Leave-p-out cross validation generalizes leave-one-out by holding out p examples for testing in each iteration instead of only 1. The slide legend marks blue as train and red as test, and the handwritten example sets .
Leave-P-out cross validation is a resampling technique used to evaluate machine learning models. In each iteration, examples are randomly selected from the dataset to serve as the test set, while all remaining examples are used to train the model. This process is repeated for a specified number of iterations.
Because the test examples are chosen randomly in each iteration, it is possible for the same data point to be included in the test set during multiple different iterations. This is a distinct feature compared to methods like K-fold cross validation where folds are typically disjoint.
Explore conditions, steps and evidence. Supplementary explanations are labeled separately from content shown in the video.
A horizontal bar labeled 'Dataset' is shown, which is then split into two adjacent rectangular blocks.
Dataset
The entire collection of data used for model building.
All available data samples
The left portion of the split dataset bar is labeled 'Training Set'.
"one is called as training set... With the help of training set we will train our machine learning model."
Training Set
The subset of data used to fit or train the machine learning model.
Subset of Dataset
The right portion of the split dataset bar is labeled 'Test Set'.
"another one is called as testing set... the model is tested with the help of testing set."
Test Set
The subset of data used to evaluate the final performance of the trained model.
Subset of Dataset
In the extended diagram, the Training Set is further divided into 'Training set' and 'Validation set'.
"This training set is again divided into two parts, the training and validation set here."
Validation Set
The subset of data used to tune hyperparameters and evaluate model performance during development.
Subset of Training Set
Slide text shows "".
The speaker says the dataset is divided into k folds and gives the example value k equal to 10.
K
Number of folds used in k-fold cross-validation; in the worked visual example it is fixed at 10.
Positive integer number of partitions of the dataset.
Rows are labeled (1), (2), ..., (10).
The speaker refers to first iteration, second iteration, and all ten iterations.
(1), (2), , (10)
Iteration index identifying which fold is held out for testing in that round.
Integers from 1 to K in the displayed example.
The speaker says, "we have set the k is equal to 5 here" and explains that this means dividing the data into five folds.
Handwritten red annotation "" appears on the right side of the slide during both the KFold and StratifiedKFold explanations.
K
Number of folds used in cross validation; in this clip it is fixed at 5.
Positive integer; here specifically .
The speaker repeatedly refers to "folds" and says each iteration uses one fold for testing and the remaining folds for training.
Each vertical bar is divided into colored segments representing folds across CV iterations.
fold
A subset of the dataset assigned either to testing or training in a given cross-validation iteration.
Subset of samples in the dataset.
The speaker says, "In this particular data set we have three classes. This is the first one and this is second one and this is third one."
The leftmost column is labeled "class" and contains three stacked colored blocks; later handwritten labels "1", "2", and "3" are added to those blocks.
class
Target category label of a sample in the dataset; the example dataset has three classes.
Categorical labels; here three distinct classes.
Legend box shows an orange/red swatch labeled "Testing set".
The speaker identifies the highlighted segment in each iteration as the fold used for testing.
Testing set
The fold held out in a given iteration and used to evaluate the model.
One fold per iteration in this example.
Legend box shows a blue swatch labeled "Training set".
The speaker says the remaining folds are used for training in each iteration.
Training set
The union of all folds not selected for testing in a given iteration.
Remaining K-1 folds per iteration in this example.
Horizontal axis is labeled "CV iteration" with tick marks 1 through 5.
The speaker walks through "first iteration," "second iteration," and so on up to the fifth.
CV iteration
Index of the cross-validation round; here there are five iterations numbered 1 to 5.
Discrete index set {1,2,3,4,5}.
Diagram showing a single dataset divided into two parts: Training Set and Test Set.
"Given a dataset, the dataset is divided into two groups. One is called as training set, another one is called as testing set."
In basic model building, the original dataset is partitioned into two disjoint subsets: a training set used to fit the model, and a test set used to evaluate its performance after training.
The dataset must be large enough to be split meaningfully.
The training and test sets should ideally be independent and identically distributed.
Diagram showing Original set split into Training set and Test set, with Training set further split into Training set and Validation set.
"The extended version of this particular model is something called as train test validation... This training set is again divided into two parts, the training and validation set here."
An extension of the basic split where the training set is further divided into a training subset (for fitting) and a validation subset (for hyperparameter tuning and intermediate evaluation). The test set remains separate for final evaluation.
Used when hyperparameter tuning is required.
Requires sufficient data to form three meaningful subsets.
Speaker states the model may go into an overfitting state where it works perfectly on training data but not on testing or real-world data.
A train/test/validation workflow diagram is shown while this point is made.
The clip defines overfitting operationally as a situation in which a model performs very well on the training data but fails to perform as expected on test data or in real-world use. This is presented as a problem motivating cross-validation.
The statement is given in the context of ordinary train/test or train/validation/test model evaluation.
No formal mathematical criterion for overfitting is stated in this clip.
Speaker says cross-validation is introduced to avoid these difficulties.
Slide text: "The idea of cross-validation arises because of the problems with train test model or train test validation model."
Slide text: "It basically wants to guarantee that the score of our model does not depend on the way we picked the train and test set."
Cross-validation is presented as a method to reduce dependence of the model score on one particular choice of training and test partition. The spoken explanation adds that the model is trained and tested using the entire dataset across the procedure.
Applies when a single fixed train/test or train/validation/test split may give an unreliable performance estimate.
Slide heading: "Types Cross Validation in Machine Learning".
List items appear as "K-folds", "Stratified K-folds", "Leave-one-out", "Leave-p-out".
Speaker names the same four types in order.
The lecture lists four cross-validation techniques before beginning the detailed explanation of the first one: K-folds, Stratified K-folds, Leave-one-out, and Leave-p-out. Only K-fold is developed further within this 120-second segment.
This is a taxonomy slide; no definitions of the latter three methods are given yet in the clip.
Speaker says the entire dataset is divided into k folds, with in the example.
Ten equal blocks per row, with one light-blue test block and nine dark-blue training blocks per iteration.
Legend labels dark blue as Training and light blue as Test.
In k-fold cross-validation, the full dataset is partitioned into k folds. The model is trained k times. In each iteration, one fold is used for testing and the remaining k-1 folds are used for training. The final reported performance is the average of the k iteration performances.
The dataset must be divisible into k folds for the displayed schematic.
The clip explicitly illustrates the case , though the method is described generally as k folds.
"we want to divide the data into five folds. In each and every iteration we want to take one fold for testing, remaining five folds for training over here."
Slide title reads "K-folds Cross Validation in Machine Learning" with chart title "KFold"; five bars labeled 1 to 5 each contain one orange/red testing block and four blue training blocks.
The spoken phrase "remaining five folds for training" conflicts with and the visible diagram; the intended meaning is the remaining four folds.
The video presents K-fold cross validation with as a method that partitions the dataset into five folds. In each of the five iterations, exactly one fold is used as the testing set and the other four folds are used as the training set. The visual sequence shows the testing fold moving from one position to another across iterations 1 through 5.
in this example
Each iteration uses one fold for testing
The remaining folds are used for training
There are five CV iterations
"To avoid this particular thing we use something called as the stratified k-fold cross validation... rather than dividing that particular data into five folds, we will divide that particular data in such a way that each of these particular folds will have equal representation of these particular classes over here."
At about 77 seconds the slide changes to "Stratified K-folds Cross Validation in Machine Learning" with chart title "StratifiedKFold"; each iteration bar contains multiple small orange/red testing segments distributed across different class regions.
The video defines stratified K-fold cross validation as a modification of ordinary K-fold splitting in which the folds are constructed so that each fold contains equal representation of each class. Visually, the testing portion in each iteration is no longer a single contiguous block but several small pieces drawn from different class regions, illustrating class-balanced holdout sets.
Used when the dataset has multiple classes
Each fold should preserve class representation
Still illustrated with and five CV iterations
"But K-fold cross validation has some disadvantages... in each and every iteration we are not taking equal representation of each of these particular classes over here."
The leftmost "class" column is annotated with 1, 2, 3; the speaker points to testing folds coming mostly from one class in early iterations and from other classes later.
The exact class-to-color mapping is visually inferable but not explicitly named in speech beyond "first," "second," and "third" class.
The clip identifies a limitation of ordinary K-fold cross validation: when the dataset contains multiple classes, a randomly chosen fold may not preserve the class proportions of the full dataset. In the shown example, some testing folds come predominantly from one class while others come from different classes, so the holdout set is not class-balanced across iterations.
Dataset contains multiple classes
Folds are not constrained to preserve class proportions
Speaker says this avoids the disadvantage of k-fold cross validation by considering equal representation of each and every class.
Slide title reads “Stratified K-folds Cross Validation in Machine Learning” and chart title reads “StratifiedKFold”.
Legend labels orange as “Testing set” and blue as “Training set”; x-axis labels are “class”, “1”, “2”, “3”, “4”, “5”; y-axis label is “Sample index”.
Stratified K-fold cross validation is presented as a variant of k-fold cross validation that keeps each class represented proportionally in the training and testing sets across folds. The visual example uses five CV iterations and shows that each iteration contains both training and testing portions from multiple classes rather than isolating one class entirely.
Used when class balance across folds matters.
Each fold should preserve the class distribution of the full dataset.
Speaker introduces “leave one out cross validation” and says it is an extreme case of k-fold cross validation.
Speaker states that one example is used for testing and the remaining n minus 1 examples are used for training.
Slide title reads “Leave-one-out Cross Validation in Machine Learning”.
Rows are labeled “Iteration ”, “Iteration ”, “Iteration ”, and “Iteration ”, with a single narrow segment separated from the rest of each bar.
Leave-one-out cross validation is defined as the special case where each iteration holds out exactly one example for testing and trains on all remaining examples. If the dataset has n examples, the procedure runs for n iterations.
Dataset size is n examples.
Each iteration uses 1 test example and n-1 training examples.
Speaker says that in k-fold cross validation data is divided into k folds, and gives the example leading to 10 groups and 10 trainings.
Red handwritten annotation writes “” on the leave-one-out slide while the speaker contrasts ordinary k-fold with leave-one-out.
The clip briefly recalls standard k-fold cross validation as dividing the data into k groups and training the model k times, once per fold. This recap is used to position leave-one-out as the limiting case where the number of folds equals the number of examples.
Data is split into k folds.
Model is trained k times.
"But in both these particular techniques... there is a bias in this particular model because certain part of the data is used for training, certain part... for validation, and remaining is for testing... So the model is not trained or tested with the entire the data's representation over here."
Using fixed train/validation/test splits introduces bias because the model is neither trained nor evaluated on the complete representation of the entire dataset.
The dataset is partitioned into fixed, non-overlapping subsets for training, validation, and testing.
For any fixed partitioning scheme
Slide text states cross-validation arises because of problems with train-test or train-test-validation models.
Slide text states it wants to guarantee the score does not depend on how the train and test set were picked.
Speaker introduces cross-validation as the way to avoid those difficulties.
Cross-validation is motivated by the problem that a model score can depend on the particular way the train and test sets are chosen; the method aims to make the score less dependent on that choice.
A machine learning model is being evaluated using some train/test partitioning scheme.
General claim about model evaluation as presented in the lecture.
Speaker says they take the average of this particular performance and that average is considered the final performance of the model.
After running all k iterations of k-fold cross-validation, the final performance of the model is taken as the average of the performances obtained across the iterations.
The model has been evaluated once on each held-out fold in the k-fold procedure.
For the k-fold procedure as described in the clip.
"In each and every iteration we want to take one fold for testing, remaining five folds for training over here."
Each of the five KFold bars shows one orange/red segment and four blue segments.
Spoken wording says "remaining five folds" although the visible setup and imply four remaining training folds.
For , each cross-validation iteration uses one fold as the testing set and the remaining folds as the training set.
The dataset has been divided into folds
For every iteration among the five CV iterations.
"in each and every iteration we are not taking equal representation of each of these particular classes over here."
The KFold figure shows testing blocks concentrated within particular class regions across different iterations.
Ordinary K-fold cross validation can produce folds whose class composition differs from the full dataset, so each iteration may not contain equal representation of all classes.
The dataset contains multiple classes
Folds are formed without stratification
In the illustrated example, across the five iterations.
"each of these particular folds will have equal representation of these particular classes over here" and "in each and every iteration we will get equal representation from each and every class of that particular data."
The StratifiedKFold figure shows testing portions split into multiple small segments across different class bands in each iteration.
The video states "equal representation" verbally; it does not formalize whether this means exact counts or approximately preserved proportions.
In stratified K-fold cross validation, the data are partitioned so that each fold contains equal representation of each class, and therefore each iteration’s testing set reflects all classes.
The dataset contains multiple classes
The splitting method is stratified K-fold cross validation
For each fold and each CV iteration in the illustrated example.
"Because of that again it may go into something called as the overfitting state over here."
The clip asserts a causal link but does not provide a formal proof or precise conditions under which the imbalance leads to overfitting.
The speaker claims that lack of equal class representation across K-fold iterations may cause the process to enter an overfitting state.
Plain K-fold CV is used on a multi-class dataset
Some folds do not equally represent all classes
In the discussed disadvantage scenario.
Speaker says, “there will not be a bias or you can say that the model will not go into overfitting state in this case.”
Speaker then says this avoids the disadvantage of k-fold cross validation by considering equal representation of each and every class.
The statement links stratification directly to avoiding bias and overfitting, but the clip does not provide a formal proof or precise conditions under which this holds.
Using stratified k-fold cross validation, with equal representation of each class across folds, avoids the disadvantage of ordinary k-fold cross validation and prevents bias or overfitting in the model evaluation process.
The method being discussed is stratified k-fold cross validation.
Each class is equally represented across folds.
For the setting described in the clip, applying stratified sampling across folds is claimed to avoid the stated disadvantage.
Speaker says leave-one-out is “the extreme case of ... k-fold cross validation.”
Speaker explains ordinary k-fold divides data into k folds, then contrasts this with using 1 test example and n-1 training examples per iteration.
Leave-one-out cross validation is an extreme case of k-fold cross validation.
The dataset has n examples.
Cross validation is framed as splitting data into folds for repeated training and testing.
For a dataset of size n, the leave-one-out scheme corresponds to the limiting case where the number of folds equals n.
Speaker says this technique is not usually used in real world because it will take a lot of time to train.
Speaker gives examples of 1000 or 10000 examples and says the model would have to be trained that many times.
The claim is qualitative about practicality; no runtime formula or benchmark is shown.
Leave-one-out cross validation is not usually used in real-world settings because it requires training the model once for every example, which becomes time-consuming for large datasets.
The dataset is large enough that repeated full model training is costly.
Each iteration requires a separate model fit.
For datasets with many examples, the number of required trainings scales with dataset size, making the method often infeasible in practice.
Speaker explains dividing the dataset into k folds, training 10 times when , holding out one fold for testing, using the remaining nine for training, and averaging performance.
Rows (1), (2), ..., (10) show the held-out test fold moving across positions while the other nine blocks remain training.
Start with the entire dataset and divide it into K folds. In the example, , so there are ten folds.
Directly stated by the speaker and shown by ten equal blocks in the diagram.
Run one iteration for each fold, giving K total training/testing rounds. With , the model is trained ten times.
Explicitly stated in the audio and represented by rows labeled (1) through (10).
In iteration i, select fold i as the test fold and use the remaining K-1 folds as training data. For , this means 1 test fold and 9 training folds each round.
Stated verbally and visible in the color-coded legend and row patterns.
Repeat the same pattern for every iteration so that each fold serves as the test fold exactly once across the full procedure.
The speaker says the same thing is followed in all ten iterations; the diagram shows the test position shifting across rows.
Collect the performance from each of the K iterations and average them to obtain the final model performance.
Explicitly stated at the end of the clip.
The 10-fold example yields ten train/test evaluations whose average is reported as the final performance estimate.
The speaker narrates the first and second iterations explicitly and then says "and so on."
Cursor and check marks move across the KFold bars from iteration 1 to iteration 5, highlighting the orange/red testing segment in each bar.
Start from the KFold chart with and five CV iterations labeled 1 through 5.
The slide title, axis labels, and handwritten establish the setup.
In iteration 1, the top segment of the first bar is marked as the testing fold, while the rest of the bar is training.
The speaker says the first fold was used for testing and the remaining folds for training; the diagram shows one orange/red block and four blue blocks.
In iteration 2, a different segment becomes the testing fold and the remaining segments stay training.
The speaker explicitly says the second fold was used for testing and the remaining folds were used for training; the cursor/check mark moves accordingly.
The same pattern continues through iterations 3, 4, and 5.
The speaker concludes with "and so on," and the figure displays analogous single-testing-block patterns in the remaining bars.
The KFold illustration demonstrates a five-round procedure in which one fold is held out for testing in each round and the other four folds are used for training.
The speaker identifies three classes and then describes which class each testing fold comes from across iterations.
Handwritten labels 1, 2, 3 are added to the leftmost class column; the pointer moves among the KFold testing blocks while discussing their class origin.
The exact mapping between colors and class numbers is visually suggested but not stated as a formal legend.
Introduce the dataset as having three classes, labeled 1, 2, and 3 in the leftmost column.
The speaker says there are three classes and handwritten numerals are added to the class blocks.
Observe that in the first iteration the testing fold comes from the third class region.
The speaker explicitly says the first testing fold is coming from the third class, and the pointer indicates the corresponding block.
Observe that in the second iteration the testing fold again comes from that same class region.
The speaker says "In the second again it is coming from this particular class."
Observe that later iterations draw testing folds from the first and second class regions instead.
The speaker says that in the last one it is coming from first and second class over here, while indicating the relevant bars.
Conclude that the testing folds do not maintain equal representation of all three classes across iterations.
This is the speaker’s stated interpretation of the observed pattern.
The plain KFold example visually and verbally demonstrates that unstratified folding can concentrate a fold’s samples in only some classes, producing class-imbalanced testing sets.
The speaker introduces stratified K-fold as the way to avoid the previous problem and explains that each fold will have equal class representation.
The slide switches to StratifiedKFold; each iteration bar contains multiple small orange/red testing segments spread across different class bands.
The video does not give an algorithmic construction rule beyond the verbal statement of equal class representation.
Replace the plain KFold slide with the StratifiedKFold slide after stating the disadvantage of K-fold CV.
At about 77 seconds the title changes to "Stratified K-folds Cross Validation in Machine Learning" and the chart title becomes "StratifiedKFold."
Keep the same overall structure of five CV iterations and .
The axes still show iterations 1 through 5 and the handwritten remains on screen.
Change the fold construction so that each fold contains samples from every class.
The speaker says the data are divided so that each fold will have equal representation of the classes.
Read the new diagram: in each iteration the testing portion appears as several small orange/red pieces distributed across different class regions rather than one contiguous block.
The StratifiedKFold figure visibly splits the testing set across multiple bands within each bar.
Conclude that each iteration now yields balanced class representation in the testing fold.
The speaker states that in each iteration we will get equal representation from each class.
Stratified K-fold cross validation is presented as a corrected partitioning scheme that preserves class composition in every fold, thereby avoiding the class-imbalance problem shown for ordinary K-fold CV.
Speaker says if we have n number of examples, we will have n iterations.
Speaker instantiates this with 100 examples, 1 for testing and 99 for training in the first iteration, repeated 100 times.
The slide lists iterations from through , visually encoding one held-out unit per row.
Start from a dataset with n total examples.
Stated directly by the speaker and represented by N in the slide labels.
In each iteration, hold out exactly 1 example for testing and use the remaining n-1 examples for training.
Explicitly stated in the audio and illustrated by the narrow separated segment in each row.
Repeat this process so that each example serves as the test example once.
Implied by the sequence of rows labeled Iteration through Iteration and by the spoken explanation.
Therefore the total number of iterations equals n.
Derived by counting one iteration per example.
For a dataset of size n, leave-one-out cross validation requires n iterations, one for each example.
Speaker says that rather than going with one example for testing in each iteration, we will go with p examples for testing in each iteration.
The slide title and printed label identify the method as Leave-P-out / Leave p out.
Red handwritten annotation sets .
The clip stops before deriving the total number of iterations for leave-p-out.
Begin with leave-one-out, where each iteration tests on 1 example.
Established earlier in the same clip.
Replace the single held-out test example by p held-out test examples in each iteration.
Explicitly stated by the speaker when introducing leave-p-out.
The displayed example specializes this to .
Shown by the handwritten annotation “” and supported by the audio example.
Leave-p-out cross validation is presented as the direct generalization of leave-one-out from 1 test example per iteration to p test examples per iteration.
A slide titled "K-Fold Cross Validation in Machine Learning" shows and ten rows labeled (1), (2), ..., (10).
Speaker walks through first and second iterations and says the same applies to all ten iterations.
Illustrate how k-fold cross-validation works when the dataset is divided into folds.
The dataset is split into 10 folds.
Each row in the diagram corresponds to one iteration.
Dark blue denotes training data and light blue denotes test data.
Determine how training and testing are assigned in each iteration and how the final performance is obtained.
Iteration (1): the first fold is used for testing and the remaining nine folds are used for training.
Explicitly stated by the speaker and shown by the leftmost light-blue block in row (1).
Iteration (2): the second fold is used for testing and the remaining nine folds are used for training.
Explicitly stated by the speaker and shown by the second light-blue block in row (2).
Iterations continue in the same manner until iteration (10), where the tenth fold is used for testing and the other nine folds are used for training.
The speaker says the same thing is followed in all ten iterations; row (10) shows the rightmost block as test.
Average the ten iteration performances to get the final performance of the model.
Stated directly in the closing sentence of the clip.
With , the model is trained and evaluated ten times, each time holding out a different fold, and the final score is the average of those ten scores.
The verification is the consistency between the spoken rule (one test fold, nine training folds per iteration) and the diagram’s color pattern across rows (1), (2), ..., (10).
The speaker walks through the first and second iterations and summarizes the rest with "and so on."
KFold chart with five bars labeled 1 to 5, each containing one orange/red testing block and four blue training blocks.
No numerical dataset size or exact sample counts are provided.
Illustrate how K-fold cross validation works when K is set to 5.
Five CV iterations labeled 1 through 5
Each iteration has one testing fold and the remaining folds for training
Show the allocation of testing and training folds across the five iterations.
Set , so the dataset is divided into five folds.
Stated directly by the speaker and written as on the slide.
In iteration 1, use one fold for testing and the other four folds for training.
Explicitly described in the audio and shown by one orange/red block plus four blue blocks in bar 1.
In iteration 2, use a different fold for testing and the remaining four folds for training.
Explicitly described in the audio and shown by the shifted orange/red block in bar 2.
Continue analogously for iterations 3, 4, and 5.
The speaker says "and so on," and the remaining bars display the same one-test/four-train pattern.
The example demonstrates five cross-validation rounds in which each round holds out one of the five folds for testing while training on the other four.
Verified against the visible KFold chart: every one of the five bars contains exactly one testing segment and four training segments.
The speaker says stratified K-fold divides the data so each fold has equal representation of the classes and repeats this for each iteration.
StratifiedKFold chart shows multiple small orange/red testing segments within each iteration bar, distributed across different class regions.
The clip does not provide exact counts per class per fold, only the qualitative balance idea.
Show how stratified K-fold cross validation maintains class representation across folds.
Dataset has three classes
Five CV iterations are shown
Demonstrate that each fold/testing set includes all classes rather than being dominated by one class.
Begin from the earlier problem that plain K-fold folds may not represent all classes equally.
The speaker introduces stratified K-fold specifically to avoid that disadvantage.
Partition the data so that each fold contains equal representation of each class.
Directly stated in the audio definition of stratified K-fold.
Inspect iteration 1 in the StratifiedKFold chart: the testing portion is split into several small orange/red pieces across different class bands.
Visible in the diagram and pointed out by the speaker as the testing fold with class representation.
Observe that the same pattern repeats in iterations 2 through 5.
The speaker says the same thing happens in the second, third, and subsequent iterations; the chart shows analogous segmented testing blocks in each bar.
The stratified example shows that each iteration’s testing set is composed of samples from all classes, preserving class balance across folds.
Verified by comparing the StratifiedKFold figure with the earlier KFold figure: testing regions are fragmented across class bands instead of concentrated in a single class region.
Speaker says, “let us say that we have some 100 examples, one example is used for testing and 99 will be used for training in the first iteration and the same thing will be done 100 times over here.”
Red handwritten annotations show “100” and below it “1, 99”.
Illustrate how leave-one-out cross validation works when the dataset contains 100 examples.
Total examples = 100.
Each iteration uses 1 example for testing.
The remaining examples are used for training.
Determine the train/test split per iteration and the total number of iterations.
Take the first iteration and hold out 1 example for testing.
Definition of leave-one-out stated in the clip.
Use the remaining 99 examples for training in that iteration.
Follows from and is explicitly spoken.
Repeat the same procedure for all examples.
Speaker says the same thing will be done 100 times.
Each iteration uses 1 test example and 99 training examples, and the full procedure runs for 100 iterations.
The answer matches both the spoken numeric example and the handwritten “100” over “1, 99” annotation.
Speaker says, “for example let us say that p is equal to 3, that is three examples will...” before the clip ends.
Red handwritten annotation writes “”.
The slide shows multiple rows with red test blocks and blue training blocks under the label “Leave p out”.
The sentence is incomplete in the provided clip, so the full consequence of choosing is not fully verbalized here.
Introduce a concrete parameter choice for leave-p-out cross validation.
Method is leave-p-out cross validation.
The chosen parameter is .
Identify what means for the test set size in each iteration.
Set the holdout size to .
Explicitly written on the slide and spoken by the speaker.
Interpret this as using three examples for testing in each iteration.
Directly follows from the speaker’s definition of leave-p-out.
When , each iteration holds out 3 examples for testing instead of 1.
This interpretation is consistent with the definition given immediately before the example, though the clip ends before further details are completed.
A horizontal bar labeled 'Dataset' appears, then splits into two blocks labeled 'Training Set' and 'Test Set'. A yellow cursor highlights each block sequentially.
Dataset bar
Training Set block
Test Set block
Yellow cursor
Dataset bar splits into two blocks
Cursor moves from Training Set to Test Set
Total length of the bar represents the full dataset
Visually demonstrates the fundamental concept of partitioning data into training and testing subsets.
A new diagram shows 'Original set' splitting into 'Training set' and 'Test set'. The 'Training set' further splits into 'Training set' and 'Validation set'. Arrows connect these to a 'Machine learning algorithm' hexagon and a 'Predictive Model' box, with a circular arrow indicating tuning/evaluation loops.
Original set
Training set (outer)
Test set
Training set (inner)
Validation set
Machine learning algorithm
Predictive Model
Circular arrows
Nested splitting of datasets is shown
Arrows indicate flow from data to algorithm to model
Circular arrows represent iterative tuning and evaluation
Test set remains isolated from the tuning loop
Illustrates the complete workflow including hyperparameter tuning using a validation set before final testing.
A flow diagram shows Original set, then Training set and Test set, then Training set, Validation set, and Test set feeding a machine learning algorithm and predictive model loop.
Speaker discusses overfitting while this diagram remains on screen.
Original set
Training set
Test set
Validation set
Machine learning algorithm
Predictive Model
Training, tuning, and evaluation loop
Final performance estimate arrow
The yellow pointer moves among the validation-related parts of the diagram while the speaker explains failure of a single split setup.
The overall workflow structure remains static during this interval.
The diagram visually contrasts simple train/test and train/validation/test workflows while the narration explains why such setups can lead to unreliable evaluation and overfitting.
Title changes to "Cross Validation in Machine Learning".
Two bullet points appear sequentially about why cross-validation is needed and what it guarantees.
Title text
First bullet text
Second bullet text
Yellow pointer
The slide first appears mostly blank, then the first bullet becomes visible, then the second bullet appears.
The topic remains the motivation for cross-validation.
The sequential text reveal structures the argument: first identify the problem with fixed splits, then state the goal of making the score independent of the particular split.
Title reads "Types Cross Validation in Machine Learning".
List items appear one by one: K-folds, Stratified K-folds, Leave-one-out, Leave-p-out.
Heading text
Four bullet items
Yellow pointer
Red check mark near K-folds
Each technique is added in sequence while the speaker names it.
A red check mark is drawn next to K-folds before moving on.
The slide functions as a taxonomy overview rather than a definition slide.
The visual enumeration prepares the viewer for a deeper treatment of the first item, K-fold cross-validation.
Slide title is "K-Fold Cross Validation in Machine Learning" with legend Training and Test and label .
Rows labeled (1), (2), ..., (10) show a light-blue test block shifting position while the rest stay dark blue.
Legend: Training (dark blue), Test (light blue)
Label
Ten-row schematic labeled (1), (2), ..., (10)
Yellow pointer
Red annotations including underline/circle around and numbers above blocks
The pointer highlights , then individual rows and blocks.
The test fold position changes from row to row: first position in row (1), second in row (2), last in row (10).
Each row contains exactly ten equal blocks.
In every displayed row, exactly one block is light blue and nine are dark blue.
The invariant one-test/nine-training pattern across all rows encodes the core rule of 10-fold cross-validation: each fold becomes the test set once while the others train the model.
Slide titled "K-folds Cross Validation in Machine Learning" with chart title "KFold"; y-axis "Sample index"; x-axis "CV iteration" with ticks 1 to 5; legend shows orange/red "Testing set" and blue "Training set"; leftmost column labeled "class" contains three stacked color blocks.
Title text
KFold chart
Leftmost class column
Five iteration bars
Legend
Handwritten
Handwritten is added on the right side early in the clip
Cursor moves among bars and highlights testing blocks
Check marks appear near selected testing blocks in iterations 1 and 2
There are five CV iterations
Each iteration bar contains one testing block and four training blocks
The legend consistently maps orange/red to testing and blue to training
The static layout establishes the standard K-fold scheme with and shows how one fold is held out per iteration.
Handwritten numerals 1, 2, and 3 are added to the three stacked blocks in the leftmost class column while the speaker discusses three classes.
The exact color-to-number assignment is visually inferable but not separately captioned.
Leftmost class column
Handwritten numerals 1, 2, 3
Numerals are written onto the three class blocks in sequence
The dataset is represented as having three classes
The rest of the KFold chart remains unchanged
This annotation turns the abstract stacked column into an explicit three-class example, enabling the later discussion of unequal class representation in folds.
Around 77 seconds the slide changes from "K-folds Cross Validation in Machine Learning" / "KFold" to "Stratified K-folds Cross Validation in Machine Learning" / "StratifiedKFold".
Exact transition frame is approximate because the change occurs during continuous narration.
New slide title
New chart title
Same axes and legend
Modified fold patterns
Title changes to Stratified K-folds Cross Validation in Machine Learning
Chart title changes to StratifiedKFold
Testing regions become fragmented across class bands in each iteration
remains indicated
Five CV iterations remain on the x-axis
Orange/red still denotes testing and blue still denotes training
The visual switch marks the conceptual move from ordinary K-fold CV to the stratified variant designed to preserve class balance.
In the StratifiedKFold chart, each of the five iteration bars contains multiple small orange/red segments distributed across different vertical regions rather than one contiguous block.
Five StratifiedKFold bars
Small orange/red testing segments
Blue training segments
Leftmost class column
Cursor points to different small testing segments across iterations
Handwritten is circled later in the clip
Each iteration still represents one cross-validation round
Testing and training color coding stays the same
The overall structure remains five iterations
The fragmented testing segments visually encode that each fold draws samples from multiple classes, illustrating stratification.
A slide titled “Stratified K-folds Cross Validation in Machine Learning” shows a chart titled “StratifiedKFold” with y-axis “Sample index” and x-axis labels “class”, “1”, “2”, “3”, “4”, “5”.
Legend maps orange to “Testing set” and blue to “Training set”.
A red handwritten note says “”.
A yellow cursor moves around the chart and title area.
The exact class proportions inside each colored block are not numerically labeled.
Title text
Chart titled StratifiedKFold
Orange testing-set blocks
Blue training-set blocks
Axis labels class and 1–5
Handwritten
Yellow cursor
Cursor moves across the chart and title.
Attention shifts from the class column to the numbered CV iteration columns.
The legend consistently maps orange to testing and blue to training.
The x-axis continues to represent class plus five CV iterations.
The visual encodes that each CV iteration contains a mixture of training and testing samples drawn across classes, illustrating proportional class representation rather than class-separated folds.
A new slide titled “Leave-one-out Cross Validation in Machine Learning” appears.
Four horizontal bars are labeled “Iteration ”, “Iteration ”, “Iteration ”, and “Iteration ”, with vertical ellipsis between the third and fourth rows.
Each bar has one narrow light segment separated from the larger teal region.
Handwritten annotations add “”, “n”, and “100” over “1, 99”.
Yellow cursor points to the title, bars, and annotations.
The slide does not explicitly color-code train versus test in a legend; the distinction is inferred from the narration and the narrow separated segment.
Title text
Four horizontal iteration bars
Labels Iteration through Iteration
Narrow light segment in each bar
Larger teal region in each bar
Handwritten , n, 100, 1, 99
Yellow cursor
Slide changes from stratified k-fold to leave-one-out.
Handwritten annotations are added sequentially: , then n, then 100 over 1, 99.
Cursor moves from title to bars to annotations.
Each row continues to represent one iteration.
Every row shows exactly one small separated portion and one large remaining portion.
The repeated pattern of one tiny held-out piece per row visually represents testing on a single example while training on the rest, and the annotations connect this to dataset size n and the 100-example example.
"there is a bias in this particular model because certain part of the data is used for training... So the model is not trained or tested with the entire the data's representation"
Learners may assume that a single train/validation/test split provides an unbiased estimate of model performance on the full data distribution.
Fixed splits inherently exclude portions of data from training or evaluation phases, leading to potential bias because the model never sees the complete dataset representation during any single phase.
Speaker says the model will work perfectly on the training data but will not work on testing or may not work as expected in the real world.
One might assume that if a model works perfectly on training data, it will also work well on unseen data.
The clip explicitly warns that a model can fit the training data very well yet fail on testing or real-world deployment; this is the overfitting state used to motivate cross-validation.
Slide text says cross-validation wants to guarantee that the score does not depend on the way the train and test set were picked.
A single chosen train/test split may be treated as an objective measure of model quality.
The lecture presents cross-validation precisely because the score from one arbitrary split can depend on how the data were partitioned.
The speaker says, "In each and every iteration we want to take one fold for testing, remaining five folds for training over here."
The KFold chart with shows one testing block and four training blocks per iteration.
With , one might hear or say that after taking one fold for testing there are still five folds left for training.
If and one fold is used for testing, only four folds remain for training. The visible diagram confirms one testing block plus four training blocks per iteration, so the spoken "remaining five folds" is inconsistent with the shown setup.
The speaker explicitly says K-fold cross validation has disadvantages because not every iteration takes equal representation of each class.
The KFold figure shows testing folds concentrated in particular class regions across iterations.
One may assume that any K-fold split automatically keeps the same class mix in every fold as in the full dataset.
The video shows that ordinary K-fold CV can produce folds dominated by one class or missing balanced representation of others; this is why stratified K-fold is introduced.
Speaker says this kind of cross validation technique is not usually used in real world because it will take a lot of time to train.
Speaker contrasts it with k-fold cross validation as the usual alternative.
One might assume that because leave-one-out uses almost all data for training in each fold, it is a default real-world choice.
The video explicitly warns that leave-one-out requires n trainings for n examples and becomes too time-consuming for large datasets such as those with 1000 or 10000 examples, so practitioners usually prefer k-fold cross validation.
Speaker explicitly addresses the possibility of the same example being tested in multiple iterations due to random selection.
Learners might assume that in cross validation, every example is tested exactly once, or that test sets across iterations are mutually exclusive.
In Leave-P-out cross validation with random selection, the same example can appear in the test set in more than one iteration. The speaker highlights this by pointing out an example tested in both the first and third iterations.
"The extended version of this particular model is something called as train test validation."
The Train-Test-Validation split generalizes the basic Train-Test split by adding a dedicated validation subset for hyperparameter tuning.
"But in both these particular techniques... there is a bias... So the model is not trained or tested with the entire the data's representation over here."
Both fixed split methods are contrasted with the implicit need for cross-validation due to their shared limitation of introducing bias by not utilizing the full dataset representation in every phase.
Speaker transitions from describing overfitting difficulties to introducing cross-validation as the solution.
Cross-validation slide explicitly says the idea arises because of problems with train-test or train-test-validation models.
The discussion of overfitting and split-dependent evaluation motivates the need for cross-validation.
The types slide lists K-folds as the first cross-validation technique.
Speaker says they will understand the different types first and then continue with K-fold cross-validation.
K-fold cross-validation is presented as one specific member of the broader family of cross-validation methods.
After explaining the fold-by-fold procedure, the speaker states that the average of the performances is the final performance.
The averaging rule depends on having first defined the k-fold iterative train/test procedure.
The speaker introduces stratified K-fold as the method used "To avoid this particular thing" after describing the disadvantage of K-fold CV.
The slide changes from KFold to StratifiedKFold while keeping the same five-iteration structure.
Stratified K-fold cross validation is presented as a refinement of ordinary K-fold cross validation that adds the requirement of class-balanced folds.
The speaker first states the disadvantage of plain K-fold CV and then says stratified K-fold is used to avoid it.
The KFold class-imbalance illustration is followed by the StratifiedKFold balanced illustration.
Understanding the class-imbalance weakness of plain K-fold CV is what motivates the introduction of stratified K-fold CV in this clip.
"Because of that again it may go into something called as the overfitting state over here."
The clip does not elaborate the mechanism connecting imbalanced folds to overfitting.
The video applies the identified class-imbalance issue as a reason why plain K-fold CV may lead to an overfitting state.
Speaker says this avoids the disadvantage of k-fold cross validation by considering equal representation of each and every class.
The slide is specifically titled Stratified K-folds Cross Validation.
Stratified k-fold is presented as a refinement of ordinary k-fold cross validation that adds class-proportional representation across folds.
Speaker calls leave-one-out the extreme case of k-fold cross validation.
Handwritten appears while the speaker contrasts ordinary k-fold with leave-one-out.
Leave-one-out is described as the limiting case of k-fold cross validation where the number of folds equals the number of examples.
Speaker introduces leave-p-out by saying that rather than using one example for testing, we use p examples for testing in each iteration.
The slide changes from a single narrow holdout per row to multiple red test blocks per row.
Leave-p-out extends leave-one-out by replacing the single held-out test example with p held-out test examples.
Speaker says leave-one-out is not usually used in real world because it takes a lot of time to train, and then says we usually go with k-fold cross validation.
The clip contrasts leave-one-out with ordinary k-fold on practical grounds: leave-one-out needs one training run per example, while k-fold uses only k runs.
"Given a dataset, the dataset is divided into two groups..."
"we will see the performance... with the help of validation set... model is tuned with the help of different hyper parameters"
"there is a bias in this particular model because certain part of the data is used for training..."
Slide text directly states the motivation for cross-validation.
Speaker explains one fold for testing and remaining folds for training in each iteration.
Color-coded rows show the held-out fold changing position.
Speaker says the average of the performances is considered the final performance.
Four cross-validation types are listed on the slide.
Opening explanation of setting and dividing data into folds.
KFold chart with five iterations.
Speaker describes disadvantages of K-fold CV and then introduces stratified K-fold to avoid them.
Contrast between KFold and StratifiedKFold charts.
Repeated statement that each fold will have equal representation of each class.
Fragmented testing segments across class bands in StratifiedKFold.
Speaker links lack of equal class representation to possible overfitting.
No formal proof or detailed mechanism is given in the clip.
Spoken inconsistency about remaining folds for training.
Visible one testing block and four training blocks per iteration.
Covered · Introduction slide listing types of Cross Validation; no mathematical content explained in this segment.
Covered · Explanation and diagram of basic Train-Test split.
Covered · Explanation and diagram of Train-Test-Validation split including tuning workflow.
Covered · Discussion of bias inherent in fixed data splitting techniques.
Covered · Audio explains overfitting while a train/test/validation workflow diagram is shown.
Covered · Slide and speech introduce cross-validation as a response to split-dependent evaluation problems.
Covered · Taxonomy slide lists four cross-validation techniques; only K-fold is developed later in the clip.
Covered · Detailed explanation and schematic of 10-fold cross-validation, ending with averaging the fold performances.
Covered · Final transition frame begins to introduce another K-fold illustration; no additional complete mathematical statement is finished within the provided 120-second clip.
Covered · Defines K-fold CV with and walks through the five training/testing iterations shown on the KFold slide.
Covered · Explains the disadvantage of plain K-fold CV on a three-class dataset and links unequal class representation to possible overfitting.
Covered · Introduces stratified K-fold CV and uses the StratifiedKFold diagram to show class-balanced folds across all five iterations.
Covered · Stratified k-fold slide, spoken rationale, and handwritten annotation.
Covered · Slide transition from stratified k-fold to leave-one-out.
Covered · Leave-one-out explanation, handwritten and ,99 annotations, and practicality discussion.
Covered · Slide transition from leave-one-out to leave-p-out.
Covered · Leave-p-out introduction, train/test legend, and handwritten annotation; explanation remains partial because the clip ends mid-sentence.
Covered · Detailed explanation and visual demonstration of Leave-P-out cross validation mechanics and its random overlap property.
Covered · Video outro summarizing topics covered and promoting future content; no new mathematical concepts introduced.
Reviewed English material v1: card/concept_card "What cross-validation is for" starting at 2:14 — Cross-validation is introduced as a way to avoid difficulties caused by a single arbitrary train/test or train/validation/test split. The slide states that it wants the model score not to depend on the particular way the train and test set were picked.
YouTube4:59Another explanation of Cross-validation.
Cross-validation
YouTube2:41Another explanation of Cross-validation.
Cross-validationYouTube2:41Whiteboard for Cross-validation, compared with the current visual explanation.
Cross-validation