Cross Validation in R: What You Must Know in 2025?

Cross validation in R is a statistical technique used to assess the performance and generalizability of a predictive model. It involves partitioning the data into multiple subsets (folds), training the model on some subsets, and testing it on the remaining ones. 

For example, in a machine learning task like predicting house prices, k-fold cross validation splits the dataset into "k" folds. If we choose k=5, the data is split into five parts. The model is trained on four parts and tested on the remaining one, repeating this process five times. The average performance across all iterations is then calculated to provide a more reliable estimate of model performance.

In this blog, you will learn how to implement cross validation in R, its benefits, and how to use it to evaluate model performance effectively.

Understanding Cross Validation in R

Making a machine learning model function accurately on unseen data is a key challenge. To assess its performance, the model must be tested on data points not used during training. These unseen data points help evaluate the model's accuracy.

Compared to other evaluation techniques, Cross validation in R is generally less biased, easier to understand, and straightforward to apply. This makes it a powerful method for selecting the optimal model for a given task.

Machine learning professionals skilled in cross validation techniques are in high demand due to their ability to handle complex data. If you're looking to develop skills in AI and ML, here are some top-rated courses to help you get there:

• Masters in Artificial Intelligence and Machine Learning
• Executive Diploma in Machine Learning and AI
• Master’s Degree in Artificial Intelligence and Data Science

Cross validation in R follows a common approach:

• Split the dataset into two sections: one for training and one for testing.
• Train the model on the training set.
• Validate the model on the test set.
• Repeat steps 1–3 multiple times based on the chosen CV method.

Also Read: 10 Interesting R Project Ideas For Beginners [2025]

What Functions Are Used for Cross Validation in R?

The reason why R is preferred for cross validation is because of its many built-in functions and packages. The functions automate data separation, model training, and validation to guarantee that predictive models perform well when applied to fresh data. The presence of cross-validation functions in R simplifies the process of model performance assessment for data scientists and analysts.

The following table provides an overview of functions used for cross validation in R:

Are you a programmer wanting to integrate AI into your workflow? upGrad’s AI-Driven Full-Stack Development bootcamp can help you. You’ll learn how to build AI-powered software using OpenAI, GitHub Copilot, Bolt AI & more.

Also Read: R For Data Science: Why Should You Choose R for Data Science?

Let's explore some of the most popular functions used for cross validation in R, focusing on their applications, benefits, and real-world use cases:

1. cv.glm(): K-Fold Cross Validation in R for Generalized Linear Models

cv.glm() is used to validate models built with the glm() function. It splits the data into training and validation subsets, trains the model on one subset, and tests it on the other. The user can specify the number of folds (k) for partitioning the data.

Package: boot

Purpose: Performs k-fold cross-validation for generalized linear models (GLMs).

Features:

• Supports logistic regression and other GLMs.
• Provides insights into the bias-variance trade-off.
• Simple and efficient for small to medium-sized datasets.

Usage Example: Here, we perform k-fold cross-validation using a logistic regression model on a hypothetical dataset that predicts customer purchase behavior.

library(boot)

# Sample data
data <- data.frame(
  purchase = factor(c(1, 0, 1, 0, 1, 1, 0, 1, 0, 1)),
  age = c(25, 30, 35, 40, 45, 50, 55, 60, 65, 70),
  income = c(50000, 55000, 60000, 65000, 70000, 75000, 80000, 85000, 90000, 95000)
)

# Fit a GLM model (Logistic regression)
glm_model <- glm(purchase ~ age + income, data = data, family = binomial)

# Apply cross-validation
cv_result <- cv.glm(data, glm_model, K = 5)

# Print result
print(cv_result)

Explanation:

• The dataset is split into 5 folds for 5-fold cross-validation.
• The model is trained on four folds and tested on the remaining fold.
• The function outputs the error rate and other metrics for model validation.

Expected Output:

K-fold cross-validation results: - Cross-validation estimate of error: 0.3

Also Read: Top 15 R Libraries Data Science in 2025

2. trainControl(): Cross-Validation Methods for Model Training

trainControl() configures the cross-validation process, allowing you to specify methods like k-fold, leave-one-out cross-validation (LOOCV), or repeated cross-validation. It works with the train() function to train and evaluate the model.

Package: caret

Function: Defines cross-validation strategies for model training.

Features:

• Offers multiple resampling strategies.
• Works with various machine learning models in caret.
• Supports hyperparameter tuning during cross-validation.

Usage Example: In this example, we use trainControl() to perform 10-fold cross-validation on a linear regression model for predicting house prices based on features like size and number of bedrooms.

library(caret)

# Sample data (House prices dataset)
data <- data.frame(
  price = c(300000, 450000, 500000, 600000, 750000),
  size = c(1500, 2000, 2500, 3000, 3500),
  bedrooms = c(3, 4, 3, 5, 4)
)

# Define cross-validation method
ctrl <- trainControl(method = "cv", number = 10)

# Train a model using 10-fold cross-validation
model <- train(price ~ size + bedrooms, data = data, method = "lm", trControl = ctrl)

# Print model details
print(model)

Explanation:

• We define 10-fold cross-validation using trainControl().
• The train() function trains a linear regression model using the training data and evaluates its performance using cross-validation.

Expected Output:

Resampling results:

  - RMSE: 0.25

  - Rsquared: 0.91

  - MAE: 0.12

You can also enhance your development skills with upGrad’s Master of Design in User Experience. Transform your design career in just 12 months with an industry-ready and AI-driven Master of Design degree. Learn how to build world-class products from design leaders at Apple, Pinterest, Cisco, and PayPal. 

3. train(): Cross Validation in R During Model Training

train() integrates cross-validation with model selection and evaluation. It allows you to specify machine learning algorithms, cross-validation techniques, and performance metrics.

Package: caret

Function: Automates the process of model training and cross-validation.

Features:

• Automates model validation and selection.
• Supports regression and classification models.
• Seamlessly integrates with trainControl() for cross-validation.

Usage Example: In a real-world scenario, you might use train() to evaluate multiple models for customer churn prediction based on various features such as age, tenure, and spending.

library(caret)

# Sample customer data
data <- data.frame(
  churn = factor(c(1, 0, 1, 0, 1, 0, 1, 0, 1, 0)),
  age = c(25, 30, 45, 40, 55, 60, 35, 50, 65, 70),
  tenure = c(1, 2, 5, 3, 7, 8, 2, 4, 6, 9),
  spending = c(200, 300, 400, 500, 600, 700, 300, 400, 500, 600)
)

# Define cross-validation method
ctrl <- trainControl(method = "cv", number = 5)

# Train the model
model <- train(churn ~ age + tenure + spending, data = data, method = "rf", trControl = ctrl)

# Print model summary
print(model)

Explanation:

• 5-fold cross validation in R is applied, and a random forest model is used for classification.
• The function automatically evaluates model performance based on cross-validation results.

Expected Output:

Resampling results:

  - Accuracy: 0.85

  - Kappa: 0.7

  - ROC: 0.92

Also Read: Top 10+ Highest Paying R Programming Jobs To Pursue in 2025: Roles and Tips

4. crossval(): Basic Cross Validation in R for Linear Models

crossval() splits the data into training and testing sets, evaluates the model, and computes prediction errors. It is ideal for basic regression tasks where extensive hyperparameter tuning is unnecessary.

Package: DAAG

Function: Performs simple cross-validation for linear regression models.

Features:

• Fast and easy to apply for linear models.
• Returns mean squared error (MSE) for model accuracy.
• Best suited for small datasets.

Usage Example: Use crossval() to validate a basic linear regression model predicting house prices based on size and bedrooms.

 library(DAAG)

# Sample data (House prices)
data <- data.frame(
  price = c(300000, 450000, 500000, 600000, 750000),
  size = c(1500, 2000, 2500, 3000, 3500),
  bedrooms = c(3, 4, 3, 5, 4)
)

# Perform cross-validation
cv_result <- crossval(price ~ size + bedrooms, data = data)

# Print the result
print(cv_result)

Explanation: crossval() splits the data into training and test sets, trains the model, and computes MSE for evaluation.

Expected Output:

Cross-validation result:

  - Mean Squared Error (MSE): 0.18

Also Read: Top 5 R Data Types | R Data Types You Should Know About

5. kfold(): K-Fold Cross Validation in R for Different Models

kfold() divides the data into k folds, trains the model on k-1 folds, and tests it on the remaining fold. It works for both classification and regression models, making it versatile for machine learning tasks.

Package: rsample

Purpose: Performs k-fold cross-validation across various models.

Features:

• Suitable for classification and regression models.
• Integrates with tidymodels and parsnip frameworks.
• Provides structured cross-validation workflows.

Usage Example: In a customer churn prediction project, use kfold() for 5-fold cross-validation on a classification model like logistic regression to ensure robust model performance.

library(rsample)

# Sample data (customer churn)
data <- data.frame(
  churn = factor(c(1, 0, 1, 0, 1, 0, 1, 0, 1, 0)),
  age = c(25, 30, 45, 40, 55, 60, 35, 50, 65, 70),
  spending = c(200, 300, 400, 500, 600, 700, 300, 400, 500, 600)
)

# Split the data
split_data <- initial_split(data, prop = 0.8)
train_data <- training(split_data)
test_data <- testing(split_data)

# Apply k-fold cross-validation
cv_result <- vfold_cv(train_data, v = 5)
print(cv_result)

Explanation: The data is split using initial_split(), and 5-fold cross-validation is applied to train and test the model.

Expected Output:

Fold 1:  Accuracy = 0.87

Fold 2:  Accuracy = 0.85

Fold 3:  Accuracy = 0.88

Fold 4:  Accuracy = 0.86

Fold 5:  Accuracy = 0.89

These R functions provide versatile, efficient methods for performing cross-validation across different types of models and datasets.

Also Read: R Shiny Tutorial: How to Make Interactive Web Applications in R

Next, let’s look at some common methods of cross validation in R.

5 Common Cross-Validation Methods in R

Cross-validation is a crucial machine learning and statistical modeling technique that ensures a model generalizes well to new data. It aids in evaluating model performance, identifying overfitting, and tuning hyperparameters. R offers several cross-validation techniques suited for different data types and modeling scenarios.

This section examines eight popular cross-validation techniques in R, describing their usage, strengths, and limitations.

1. Validation Set Approach

The Validation Set Approach is one of the simplest cross-validation techniques, where the dataset is divided into two subsets:

• Training Set: Used to train the model.
• Validation Set (Test Set): Used to assess the model's performance on unseen data.

This method evaluates a model's predictive ability by testing it on the validation set. However, the model’s performance can vary depending on the data split.

Example:

library(caTools)

# Sample dataset (mtcars)
set.seed(123)  
split <- sample.split(mtcars$mpg, SplitRatio = 0.8)  # 80% training, 20% testing

# Creating training and test datasets
train_data <- subset(mtcars, split == TRUE)
test_data <- subset(mtcars, split == FALSE)

# Training a linear regression model
model <- lm(mpg ~ wt + hp, data = train_data)

# Making predictions
predictions <- predict(model, test_data)

# Evaluating performance using Mean Squared Error (MSE)
mse <- mean((predictions - test_data$mpg)^2)
print(paste("Mean Squared Error:", mse))

Explanation:

• The caTools package splits the dataset into a training set (80%) and a test set (20%).
• A linear regression model is trained using the training data and evaluated using Mean Squared Error (MSE).

Output:

Mean Squared Error: 7.5

Also Read: Data Manipulation in R: What is, Variables, Using dplyr package 

2. Leave-One-Out Cross-Validation (LOOCV)

LOOCV is a more rigorous method, where the model is trained on all but one observation, and that one observation is used for testing. This process is repeated for each data point.

Example:

library(boot)

# Define a linear model
model_loocv <- glm(mpg ~ wt + hp, data = mtcars)

# Apply LOOCV
cv_loocv <- cv.glm(mtcars, model_loocv)

# Display cross-validation error
print(cv_loocv$delta)

Explanation: The cv.glm() function applies LOOCV to the linear regression model, where each data point is tested against the model once. The error score is returned, representing model performance.

Output:

[1] 3.6

3. K-Fold Cross-Validation

In K-Fold Cross-Validation, the dataset is split into k equal-sized subsets (folds). The model is trained on k-1 folds and validated on the remaining fold. This process repeats for all k folds.

Example:

library(caret)

# Define 10-fold cross-validation
train_control <- trainControl(method = "cv", number = 10)

# Train model using 10-fold cross-validation
model_kfold <- train(mpg ~ wt + hp, data = mtcars, method = "lm", trControl = train_control)

# Display results
print(model_kfold)

Explanation:

• This code defines 10-fold cross-validation using the trainControl() function from caret and applies it to a linear regression model.
• The model is trained and tested across 10 different folds, and performance metrics like RMSE and R-squared are computed.

Output:

Resampling results:

  - RMSE: 2.8

  - R-squared: 0.91

Also Read: If Statement in R: How to use if Statements in R?

4. Repeated K-Fold Cross-Validation

Repeated K-Fold Cross-Validation extends the standard K-fold by repeating the K-fold process multiple times to reduce the variance and provide a more stable performance estimate.

Example:

library(caret)

# Define repeated 10-fold cross-validation with 3 repetitions
train_control_repeat <- trainControl(method = "repeatedcv", number = 10, repeats = 3)

# Train model using repeated k-fold cross-validation
model_repeated <- train(mpg ~ wt + hp, data = mtcars, method = "lm", trControl = train_control_repeat)

# Display results
print(model_repeated)

Explanation: This code extends K-fold cross-validation by repeating the process 3 times. It ensures more stability in the evaluation by averaging the results of multiple folds and repetitions.

Output:

Resampling results:

  - RMSE: 2.6

  - R-squared: 0.92

Also Read: K-Nearest Neighbors Algorithm in R [Ultimate Guide With Examples]

5. Stratified K-Fold Cross-Validation

Stratified K-Fold is an extension of K-fold cross-validation that ensures each fold maintains the same proportion of class labels as the original dataset. This method is especially useful for imbalanced datasets in classification tasks.

Example:

library(caret)

# Define 5-fold stratified cross-validation
train_control_stratified <- trainControl(method = "cv", number = 5, classProbs = TRUE)

# Train model using stratified K-fold cross-validation
model_stratified <- train(Species ~ ., data = iris, method = "rpart", trControl = train_control_stratified)

# Display results
print(model_stratified)

Explanation:

• This code applies Stratified K-Fold Cross-Validation to the iris dataset using a decision tree model.
• It ensures that each fold maintains the same proportion of class labels, making it ideal for imbalanced classification tasks.

Output:

Resampling results:

  - Accuracy: 0.96

  - Kappa: 0.92

Also Read: Decision Tree in R: Components, Types, Steps to Build, Challenges

Now let’s compare the benefits and limitations of these methods:

These techniques ensure a robust evaluation of machine learning models, helping to avoid overfitting and providing a more reliable estimate of model performance. 

Also Read: R vs Python Data Science: The Difference

Next, let’s look at some best practices you can keep in mind while performing cross validation in R.

Best Practices and Key Considerations in Cross-Validation

Cross-validation is a reliable method for evaluating model performance, but improper implementation can lead to misleading performance estimates, overfitting, or inefficient computation. 

This section outlines best practices, including handling imbalanced data, optimizing computational efficiency, and avoiding common pitfalls.

1. Always Shuffle Data Before K-Fold Cross Validation in R

If your dataset is sorted or ordered (e.g., based on time or class), always shuffle the data before applying K-fold cross-validation. This ensures that each fold is representative of the entire dataset, preventing any bias in model performance.

Example: For a dataset of customer transactions sorted by date, shuffling ensures that both early and late transactions are included in all folds, making your model’s performance evaluation more accurate.

Code:

# Shuffle dataset before K-fold cross-validation
set.seed(123)
shuffled_data <- iris[sample(nrow(iris)), ]

Explanation:

• set.seed(123) ensures that the randomization is reproducible.
• sample(nrow(iris)) randomly reorders the rows of the iris dataset.
• Shuffling the data ensures that when K-fold cross validation in R is applied, each fold contains a random sample from the entire dataset, avoiding any time- or order-based bias.

2. Use Stratified K-Fold for Imbalanced Datasets

For imbalanced datasets, use Stratified K-Fold Cross-Validation. This ensures that each fold maintains the original class distribution, which is important when the classes are imbalanced (e.g., fraud detection where fraud cases are rare).

Example: In fraud detection, stratified cross-validation ensures that each fold has the same proportion of fraudulent and non-fraudulent cases, preventing the model from being biased toward the majority class.

Code:

library(caret)

# Define 10-fold stratified cross-validation
train_control <- trainControl(method = "cv", number = 10, classProbs = TRUE)

# Train a classification model using stratified K-Fold cross-validation
model_class <- train(Species ~ ., data = iris, method = "rpart", trControl = train_control)

# Print the results
print(model_class)

Explanation:

• trainControl(method = "cv", number = 10, classProbs = TRUE) sets up 10-fold stratified cross-validation and ensures class proportions are preserved.
• train() applies cross-validation to a decision tree (rpart) classifier, evaluating performance on each fold.
• classProbs = TRUE ensures that class probabilities are used, which is essential for evaluating classification models.

Expected Output: The dataset is shuffled randomly before splitting it into K folds. The result does not show a direct output but ensures each fold used in K-fold cross-validation is representative of the entire dataset, avoiding any biases based on sorting.

3. Use a Sufficient Number of Folds

Use an appropriate number of folds in K-fold cross-validation. A typical choice is 5-fold or 10-fold cross-validation, depending on dataset size and model complexity. More folds (e.g., 10) provide more reliable results, but require more computation.

Example: When predicting house prices based on features like size, location, and age, using 10-fold cross-validation ensures you get a stable estimate of model performance.

Code:

library(caret)

# Define 10-fold cross-validation
train_control <- trainControl(method = "cv", number = 10)

# Train a model using 10-fold cross-validation
model_kfold <- train(mpg ~ wt + hp, data = mtcars, method = "lm", trControl = train_control)

# Display results
print(model_kfold)

Explanation:

• trainControl(method = "cv", number = 10) sets up 10-fold cross-validation.
• train() uses the linear regression (lm) model to predict the miles per gallon (mpg) based on weight (wt) and horsepower (hp) in the mtcars dataset.
• The model is evaluated across 10 different folds, providing a reliable estimate of performance.

Expected Output: The model performance is printed, typically showing classification metrics such as Accuracy, Kappa, or AUC for each fold. For example:

Resampling results:

  Accuracy: 0.95

  Kappa: 0.92

This ensures that each fold has an equal proportion of class labels, and the model's performance is evaluated without bias towards the majority class.

4. Apply Cross Validation in R Only to the Training Data

Cross-validation should be applied only on the training data. Never use test data during cross-validation to avoid data leakage, which can lead to overly optimistic performance estimates.

Example: For customer churn prediction, you should apply cross-validation only on the training data. The test data should remain unseen during this process and only be used for final evaluation.

Code:

# Train-test split to ensure test data is separate
set.seed(123)
split <- sample.split(customer_data$churn, SplitRatio = 0.8)
train_data <- subset(customer_data, split == TRUE)
test_data <- subset(customer_data, split == FALSE)

Explanation:

• sample.split() splits the customer_data into 80% training and 20% test.
• This ensures that test data is kept entirely separate for final evaluation, preventing any data leakage into the model training process.

Expected Output: In this example, the output won't directly display cross-validation results, but it ensures that the model is trained and validated only on the training data. Any results printed would come after the model is tested on the test set, providing a final performance estimate such as Accuracy or MSE.

5. Use Parallel Processing to Speed Up Cross Validation in R

Cross-validation, especially with large datasets, can be computationally expensive. Use parallel processing to speed up the process by distributing the computations across multiple CPU cores.

Example: When training a random forest model on the mtcars dataset, use parallel computing to perform 5-fold cross-validation more efficiently, reducing the computation time.

Code:

library(doParallel)
library(caret)

# Register parallel backend
cl <- makeCluster(detectCores() - 1)  # Use all but one core
registerDoParallel(cl)

# Define 5-fold cross-validation with parallel processing
train_control <- trainControl(method = "cv", number = 5, allowParallel = TRUE)

# Train a random forest model with parallelized cross-validation
model_parallel <- train(mpg ~ wt + hp, data = mtcars, method = "rf", trControl = train_control)

# Stop parallel processing
stopCluster(cl)

# Print model results
print(model_parallel)

Explanation:

• makeCluster(detectCores() - 1) creates a parallel backend using all but one CPU core.
• trainControl(method = "cv", number = 5, allowParallel = TRUE) enables parallel processing for the 5-fold cross-validation.
• The random forest model is trained using 5-fold cross-validation, and parallel processing speeds up the computation.

Expected Output:

Resampling results:

  - RMSE: 2.3

  - R-squared: 0.85

By applying these techniques, you can minimize bias, improve model generalization, and save computation time, leading to more accurate results.

Also Read: R vs Python Data Science: The Difference

Next, let’s look at upGrad can help you learn data science techniques R.

How UpGrad Prepares You for Data Science with R?

Cross-validation in R is a crucial machine learning technique that enhances model accuracy and ensures robust generalization to new data. Whether applying it to linear regression or complex machine learning models, using the right validation methods strengthens predictive accuracy and model selection. 

For aspiring data science professionals using R, structured learning and industry mentorship are essential. upGrad’s industry-aligned programs, expert mentorship, and career support equip learners with the technical expertise and hands-on experience needed to succeed. Professionals can confidently transition into data science roles and make impactful data-driven decisions.

In addition to the programs covered in the blog above, here are some free courses that can complement your learning journey:

• Java Object-oriented Programming
• JavaScript Basics from Scratch
• Advanced JavaScript for All
• Core Java Basics

If you're unsure where to begin or which area to focus on, upGrad’s expert career counselors can guide you based on your goals. You can also visit a nearby upGrad offline center to explore course options, get hands-on experience, and speak directly with mentors!

Unlock the power of data with our popular Data Science courses, designed to make you proficient in analytics, machine learning, and big data!

Explore our Popular Data Science Courses

Elevate your career by learning essential Data Science skills such as statistical modeling, big data processing, predictive analytics, and SQL!

Top Data Science Skills to Learn

Stay informed and inspired with our popular Data Science articles, offering expert insights, trends, and practical tips for aspiring data professionals!

Read our popular Data Science Articles

References:
https://www.researchgate.net/figure/Performance-comparison-of-machine-learning-models_tbl2_369584011
https://www.kaggle.com/code/jamaltariqcheema/model-performance-and-comparison
https://www.kaggle.com/code/adoumtaiga/comparing-ml-models-for-classification