Heart Disease Prediction Project Using R

This Heart Disease Prediction Project in R is an easy-to-understand and beginner-friendly project. This blog will explain the process of building a classification model to predict the presence of heart disease. 

We'll be using Google Colab and R. The project covers essential steps like data cleaning, exploration, model training with logistic regression and random forest, and model evaluation. We will use simple R packages such as caret, randomForest, and caTools to make the workflow easy to follow.

Redefine Your Future with upGrad’s Data Science Courses. Join the next wave of AI and analytics leaders. Learn from the best, build real-world skills, and get globally recognized. Enrol today, your data-driven career starts here.

Must Read For Beginners: Top 25+ R Projects for Beginners to Boost Your Data Science Skills in 2025

How Long This Project Takes, What Tools You'll Use, and Skills You'll Gain

This heart disease prediction project requires a certain level of skills, time, and tools. These are mentioned in the table below.

From AI-powered finance to advanced data science, our globally recognized programs equip you to lead in tomorrow’s tech economy. Explore top data science and AI courses. Enrol now.

• B.Sc. in Artificial Intelligence & Finance
• MS in Data Science from Liverpool John Moores University
• Executive Diploma in Data Science and AI from IIITB

Stepwise Guide to Creating a Heart Disease Prediction Model Using R

The full breakdown of this project is discussed in this section, where each step is explained along with the output.

Step 1: Set Up Google Colab to Use R

To begin working with R in Google Colab, you'll first need to switch the notebook's default language from Python to R. This setup allows you to write and execute R code seamlessly within the Colab environment. 

Start by opening a new notebook in Google Colab. Then, navigate to the "Runtime" menu at the top, and select "Change runtime type." In the window that will appear, change the language setting to "R" from the dropdown menu. Once done, click "Save" to apply the changes. Your notebook is now ready to run R code.

Step 2: Install All Required R Packages

Once the R environment is active in Google Colab, the next step is to install all the essential R packages you'll need throughout the project. These packages support data cleaning, visualization, machine learning model creation, and evaluation. This is a one-time function. The code to install the required packages is:

# Install packages (only needed once)
install.packages("tidyverse")     # Data wrangling and visualization
install.packages("caret")         # Machine learning and model evaluation
install.packages("e1071")         # Support Vector Machine (used by caret)
install.packages("randomForest")  # Random Forest classifier
install.packages("caTools")       # Splitting the dataset

The above code will install all necessary packages for this project. The output is given below.

Here are some fun R projects: Daily Temperature Forecast Analysis Using R

Step 3: Load the Installed Libraries into Your Session

After installing the required packages, you need to load them into your R session so their functions are available for use. This step makes sure you can access tools for data wrangling, visualization, model training, and evaluation throughout your analysis. Here’s the code to load the libraries:

# Load the installed libraries
library(tidyverse)      # For data manipulation and visualization
library(caret)          # For machine learning workflows and evaluation
library(e1071)          # Supports algorithms used by caret (like SVM)
library(randomForest)   # For building random forest models
library(caTools)        # For splitting the dataset into training/testing sets

Upon successful loading of the libraries, we get the output confirming the same:

Step 4: Load the Dataset into R

As the project is now ready to go ahead, it's time to load the heart disease dataset. After you've manually uploaded the CSV file to your Google Colab session, you can read it into R using read.csv(). This step stores the data in a variable called data, which you’ll use for analysis and model building. To confirm that everything loaded correctly, it's a good idea to preview the first few rows. Here’s the code:

# Read the CSV file
data <- read.csv("Heart Disease Prediction.csv")

# View the first few rows of the dataset
head(data)

The above code gives us a glimpse of the dataset we’ll work with:

Step 5: Understand the Structure and Summary of the Dataset

Before starting with cleaning or modeling, it's important to understand the dataset we're working with. This step helps you inspect the types of variables (e.g., numeric, categorical), the number of features, and their basic statistical properties. Here’s the code:

# Check the structure of the dataset (column types and sample values)
str(data)

# Get summary statistics for each column
summary(data)

The above code gives us the structure of the dataset.

Step 6: Check and Handle Missing Values

Cleaning the dataset is a crucial step before any modeling. Missing values can lead to inaccurate or failed model training. This step checks how many missing (NA) values exist in each column and removes any rows containing them using na.omit(). Here’s the code to check and handle missing values:

# Check for missing values in each column
colSums(is.na(data))

# Remove rows with missing values (if any are present)
data <- na.omit(data)

The output for the above code is:

Step 7: Convert the Target Variable to a Factor

Since this is a classification problem, the target variable (which indicates whether a person has heart disease or not) must be treated as a categorical variable. In R, we do this by converting it to a factor. This step also includes checking the class distribution to see how many observations fall into each category (e.g., 0 for no disease, 1 for disease). Here’s the code:

# Convert target to factor (for classification tasks)
data$target <- as.factor(data$target)

# View how many cases are in each class (0 = No disease, 1 = Disease)
table(data$target)

The above code gives us the output:

The above output means that the dataset has two classes in the target variable:

• 499 rows where target = 0 → These represent people without heart disease.
• 526 rows where target = 1 → These represent people with heart disease.

Read More: Spam Filter Project Using R with Naive Bayes – With Code | Spotify Music Data Analysis Project in R

Step 8: Split the Dataset into Training and Testing Sets

To evaluate your machine learning model properly, it's important to divide the dataset into two parts: one for training the model and one for testing how well it performs on unseen data. Here, we use a 70-30 split, where 70% of the data goes into training, and the remaining 30% is reserved for testing. Here’s the code for this step:

# Set seed to ensure the same random split every time
set.seed(123)

# Split data: 70% for training, 30% for testing
split <- sample.split(data$target, SplitRatio = 0.7)

# Create the training set
train <- subset(data, split == TRUE)

# Create the testing set
test <- subset(data, split == FALSE)

Step 9: Train a Logistic Regression Model

Now that the data is split, it’s time to train your first machine learning model. Logistic regression is a simple and widely used classification algorithm that works well for binary outcomes like predicting heart disease (yes or no). The code is:

# Train logistic regression model using all features
model_log <- glm(target ~ ., data = train, family = "binomial")

# Display the model summary to see feature significance and statistics
summary(model_log)

The output of the above step is:

The above output means that:

• Important Features: Variables like sex, cp (chest pain), thalach (heart rate), exang (exercise-induced angina), and thal are statistically significant, meaning they strongly influence heart disease prediction.
• Significance Levels: Stars (***, **, *) next to p-values show how important a feature is. More stars = more influence on the outcome.
• Model Fit: The residual deviance dropped from 993.47 to 498.70, showing the model fits the data much better than a model with no predictors.
• AIC Value: The AIC score (526.7) helps compare models; lower is better, and it shows this model is efficient.

Step 10: Make Predictions with the Logistic Regression Model

In this step, we will use the trained logistic regression model to predict probabilities on the test set. Then, convert those probabilities into class labels (0 or 1) using a 0.5 threshold. The code for this step is:

# Predict probabilities on the test set
pred_probs <- predict(model_log, newdata = test, type = "response")

# Convert predicted probabilities to class labels using 0.5 as the cutoff
predictions <- ifelse(pred_probs > 0.5, 1, 0)

# Convert to factor to match the format of actual labels
predictions <- as.factor(predictions)

Here are some R projects you can try: Movie Rating Analysis Project in R | Forest Fire Project Using R - A Step-by-Step Guide

Step 11: Evaluate the Logistic Regression Model

Now that predictions have been made, it's time to evaluate how well the model performed. We’ll use a confusion matrix to compare the predicted values against the actual values in the test set. This will show the model's accuracy, sensitivity, specificity, and more. The code is:

# Evaluate predictions using a confusion matrix
confusionMatrix(predictions, test$target)

The output for the above step is:

The above output means that:

• The model achieved an accuracy of 85.4%, showing strong performance.
• Sensitivity is 79.3% and specificity is 91.1%, indicating reliable detection of both classes.
• Kappa score of 0.71 suggests strong agreement beyond chance.
• McNemar’s test p-value (0.017) shows a slight imbalance in classification errors.

Step 12: Train and Evaluate a Random Forest Classifier

Now let's build a Random Forest model and assess its performance on the test data. Random Forest is an ensemble method that builds multiple decision trees and combines their outputs for better accuracy. Here’s the code:

# Train Random Forest model
model_rf <- randomForest(target ~ ., data = train, ntree = 100)

# Predict on test set
rf_predictions <- predict(model_rf, newdata = test)

# Evaluate the model
confusionMatrix(rf_predictions, test$target)

The above code gives us the output as:

The above output means that:

• High Accuracy: The model correctly predicted ~98.7% of the test cases, showing excellent performance.
• Very Low Errors: Only 4 total misclassifications out of 308 test cases (1 false negative, 3 false positives).
• High Sensitivity & Specificity: It correctly identified 99.3% of class 0 cases and 98.1% of class 1 cases.
• Kappa Score of 0.974: This indicates almost perfect agreement between predicted and actual values beyond chance.

Step 13: Plot Important Features Identified by Random Forest

This step helps you visualize which features had the most impact on predicting heart disease. Random Forest automatically ranks variables based on how much they improve the model’s accuracy. The code for this step is:

# Plot variable importance from Random Forest
varImpPlot(model_rf)

This gives us a graph of the variable importance from Random Forest:

The above graph shows that:

• Top Predictors: The features thal, ca, and cp (chest pain type) are the most important for predicting heart disease; they have the highest impact on the model’s accuracy.
• Measured by Gini: Importance is measured by Mean Decrease in Gini, which shows how much a variable helps in splitting decision trees effectively. Higher values = more influence.
• Least Important: Features like fbs (fasting blood sugar) and restecg (resting ECG results) contribute the least to prediction accuracy.
• Practical Insight: Focusing on the top 4–5 features (e.g., thal, ca, cp, thalach) can give strong predictive power with less complexity.

Conclusion

In this Heart Disease Prediction project, we built a Random Forest classification model using R in Google Colab to predict the likelihood of heart disease based on clinical features like chest pain type, thalassemia, and number of major vessels.

After preprocessing the data, we split it into training and testing sets using a 70/30 ratio, trained the model, and evaluated its performance using a confusion matrix and classification metrics.

The model achieved a high accuracy of 98.7%, with strong sensitivity (99.3%) and specificity (98.1%), indicating excellent performance in identifying both heart disease and non-disease cases.

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

Colab Link:
https://colab.research.google.com/drive/13mkc60XdZtbFVxk25gqK4xnbzMG6ZCdr#scrollTo=K9mda-O9p5Gf