DEV Community: Vishnu Ajit

How to Potentially Pay Off a 25-Year Home Loan in Under 15 Years

Vishnu Ajit — Sun, 02 Aug 2026 09:38:49 +0000

How to Potentially Pay Off a 25-Year Home Loan in Under 15 Years

Disclaimer: This article is for educational purposes only and is based on simplified assumptions. Mutual fund returns are not guaranteed, and actual returns can vary significantly. Always consult a qualified financial advisor before making investment decisions.

Note:

While the whole software industry is busy making AI into man's slave/servant. We are under the premise of making AI into an intelligent secretary. Anyways AI is intelligent and AI is hardworking. So why not make it do the calculations we humans find difficult?

Mutual Fund companies only advertise concepts that bring them profits. You might have only heard of SIP - Systematic Investment plan.

But that doesnt mean there arent investment plans that bring profits to the customer. Here we bring to light 2 investment plans all major mutual fund providers have but nobody knows much about. The STP and the SWP - The Systematic Transfer Plan and the Systematic Withdrawal Plan

Introduction

For many people, buying a home is one of life's biggest milestones. Unfortunately, it often comes with a 25-year or even 30-year home loan.

Once the EMI starts, many homeowners simply accept that they will be paying it for the next two or three decades.

But what if there was another way?

Instead of using every extra rupee to prepay the loan, could you build an investment that eventually grows large enough to pay off the remaining loan balance years earlier?

This article explores one such strategy using mutual funds and the power of long-term compounding.

This is not a shortcut or a guaranteed formula. Instead, it's a way of thinking about balancing debt repayment with long-term wealth creation.

Why Most Homeowners Think About Prepaying

When people receive a bonus, inheritance, or other lump sum, the first instinct is often:

"I'll use this to reduce my home loan."

And there's nothing wrong with that.

Every rupee prepaid reduces future interest payments and helps you become debt-free sooner.

However, there's another important question worth asking.

Could that same money grow faster if invested wisely over the long term?

If the answer is yes, your investment may eventually become large enough to clear the remaining loan while also helping you build wealth.

That is the idea explored in this article.

The Investment Strategy

The strategy uses two mutual funds, each with a different purpose.

Fund A – Your Wealth Generator

Fund A is where you invest your initial lump sum.

For this example, we'll assume it generates an average annual return of 12%.

The important rule is simple:

Never withdraw the principal.
Allow it to keep generating annual profits.

Think of Fund A as your income-producing asset.

Fund B – Your Compounding Machine

Every year, instead of spending the profits generated by Fund A, you transfer only those profits into another mutual fund.

This becomes Fund B.

Fund B also remains invested and continues compounding over many years.

Now you have:

Fund A continuously producing profits.
Fund B continuously compounding those profits.

Instead of one investment snowball, you've created two.

Assumptions Used in This Example

Home Loan Assumptions

Item	Value
Loan Amount	₹50 lakh
Interest Rate	8.5% p.a.
Loan Tenure	25 years
Monthly EMI	₹40,300
Annual EMI	₹4.84 lakh

Investment Assumptions

Item	Value
Annual Return (Fund A)	12%
Annual Return (Fund B)	12%
Principal Withdrawn	Never
Profit Transfer	Once per year

How the Strategy Works

Let's assume you start with ₹10 lakh.

The principal remains invested forever.

At an assumed annual return of 12%, Fund A generates approximately ₹1.2 lakh every year.

Instead of withdrawing that money for spending, you transfer it into Fund B.

Now something interesting happens.

The ₹10 lakh continues generating another ₹1.2 lakh next year.

Meanwhile...

The ₹1.2 lakh transferred last year is also growing.

Every year, another ₹1.2 lakh joins Fund B.

Eventually, Fund B becomes a significant investment on its own.

The Mathematics Behind the Strategy

This strategy looks almost too simple.

So why does it work?

The answer lies in compounding.

Three important things happen simultaneously:

1. Your Principal Never Shrinks

Unlike withdrawing from your investment every year, your original capital remains untouched.

It continues generating profits year after year.

2. Every Year's Profit Starts Its Own Compounding Journey

The first year's profit compounds for 24 years.

The second year's profit compounds for 23 years.

The third year's profit compounds for 22 years.

...

The twenty-fifth year's profit compounds for one year.

Each transfer becomes its own growing investment.

3. You Create a Ladder of Compounding

Instead of relying on one investment,

you create dozens of smaller investments,

all compounding simultaneously.

This creates what we can think of as a ladder of compounding, where every annual profit continues working independently.

Time becomes your biggest asset.

Investment Growth Comparison

Initial Capital	Annual Profit Transferred	After 5 Years	After 10 Years	After 15 Years	After 20 Years	After 25 Years
₹1 lakh	₹12,000	₹1.76 lakh	₹3.10 lakh	₹5.35 lakh	₹9.09 lakh	₹15.33 lakh
₹10 lakh	₹1.20 lakh	₹17.64 lakh	₹31.06 lakh	₹53.48 lakh	₹90.90 lakh	₹1.53 crore
₹15 lakh	₹1.80 lakh	₹26.46 lakh	₹46.59 lakh	₹80.22 lakh	₹1.36 crore	₹2.30 crore
₹20 lakh	₹2.40 lakh	₹35.28 lakh	₹62.12 lakh	₹1.07 crore	₹1.82 crore	₹3.07 crore
₹25 lakh	₹3.00 lakh	₹44.10 lakh	₹77.65 lakh	₹1.34 crore	₹2.27 crore	₹3.83 crore

Notice something interesting.

The principal never changes.

Yet your wealth keeps increasing because every year's profits continue compounding.

Comparing Your Investment With the Home Loan

While your investment is growing...

Your home loan is shrinking.

Every monthly EMI reduces a portion of the outstanding principal.

Although the reduction is slow during the early years, the outstanding balance gradually decreases.

Eventually, the two curves begin moving toward each other.

One is falling.

The other is rising.

At some point, your investment corpus may become larger than the remaining loan balance.

That is the point where you could choose to clear the remaining loan.

Scenario Comparison

Initial Investment	Investment Value after 10 Years	After 15 Years	After 20 Years	Enough to Close ₹50L Loan?
₹10 lakh	₹31.06 lakh	₹53.48 lakh	₹90.90 lakh	Around Year 15*
₹15 lakh	₹46.59 lakh	₹80.22 lakh	₹1.36 crore	Before Year 15*
₹20 lakh	₹62.12 lakh	₹1.07 crore	₹1.82 crore	Around Year 10–12*
₹25 lakh	₹77.65 lakh	₹1.34 crore	₹2.27 crore	Around Year 10*

*Illustrative estimates based on the assumptions used in this article.

What If You Start With Different Amounts?

Every investor begins from a different place.

Some may have only ₹5 lakh available.

Others may already have ₹30 lakh or even ₹50 lakh ready to invest.

The same strategy can be adapted to different starting amounts.

The only thing that changes is time.

Larger initial investments generally build the payoff corpus faster.

Smaller investments simply require more patience.

Advantages of This Strategy

Your original investment remains intact.
You continue building wealth while paying your EMI.
Compounding works on multiple yearly investments.
You maintain investment flexibility.
You may become debt-free years earlier than the original loan tenure.
You are building assets instead of only reducing liabilities.

Risks You Should Understand

Every investment strategy has risks.

This one is no different.

Mutual funds do not guarantee 12% annual returns.
Markets can experience prolonged downturns.
Home loan interest rates may change.
Taxes can affect actual returns.
Your investment timeline may differ from the illustrations shown here.

This strategy works best when viewed over the long term.

Frequently Asked Questions

Why not simply prepay the loan?

Because investing may generate higher long-term returns than the loan interest rate—but this is not guaranteed.

What if returns are only 10%?

Your investment corpus will still grow, but it may take longer to reach the loan payoff target.

Can I use index funds?

Many investors use diversified equity index funds for long-term investing, though every investment carries market risk.

Should I stop paying my EMI?

Absolutely not.

This strategy assumes you continue paying your regular EMI throughout.

Is this guaranteed to work?

No.

It depends on future investment returns, loan interest rates, taxes, and your own financial discipline.

Key Takeaways

Home loan prepayment isn't the only strategy available.
Long-term investing can become a powerful wealth-building tool.
Keeping your principal invested allows it to keep generating returns.
Every annual profit can become another compounding investment.
Over many years, your investment corpus may eventually exceed the remaining home loan balance.
Time and discipline are the two biggest factors behind this strategy.

A Different Way to Think About Home Loans

For decades, homeowners have focused on one question:

"How can I repay my loan faster?"

Perhaps there's another question worth asking.

"How can I build enough wealth that the loan no longer feels like a burden?"

This strategy isn't about avoiding debt.

It isn't about chasing unrealistic returns.

It's about understanding how time, discipline, and compounding can work together.

For some investors, aggressively prepaying a loan may still be the best choice.

For others, building a disciplined investment alongside the loan could provide both financial flexibility and long-term wealth creation.

The numbers in this article are only illustrations—but they highlight an important idea:

Sometimes, becoming debt-free isn't just about paying faster.

It's about growing smarter.

4 reasons why ditching Machine Learning and falling in love with Deep Learning might be a good idea

Vishnu Ajit — Tue, 20 Jan 2026 11:13:17 +0000

In this project we make the AI learn how to recognize the difference between two flowers. We train the AI on images upward of 500qty . Then we give a Machine Learning AI model (ML model) the same set of two folders - Rose flower folder and Carnation flower folder.

We make the ML model (Machine Learning model ) analyze both folders.

We make the DL model (Deep Learning model ) analyze both folders.

Then we try to interpret the results and see which model obtained higher accuracy.

Note: We are going to purposefully make things difficult for AI . Which is why we chose two red colour flowers. Both of which are almost the same shape geometrically. If we had chosen Rose flowers vs Jasmine flowers. Or Rose flowers vs Tulip flowers the AI models would get an advantage of deciding which is which by looking at the color difference between the flower. In this case, that is not possible. Both AI models - the Machine Learning model & the Deep Learning model has to figure out which is which with pure hardwork and render us our required results.

TLDR - Find the complete source code in this notebook

https://github.com/ruforavishnu/Project_Machine_Learning/blob/master/rose_vs_carnation_ml_vs_dl.ipynb

Complete source code in google colab notebook format can be obtained here

Dataset Exploration

We used the Flowers Kaggle Dataset and extracted Rose and Carnation images. To understand the challenge, we previewed 10 random images per class.

Even for humans, distinguishing these two red flowers is tricky — imagine how the AI has to work!

Machine Learning Approach

We resized images to 128x128 pixels and converted them to grayscale. Then we extracted HOG features to capture the flowers’ textures and shapes.

from skimage.feature import hog

# Convert to grayscale
X_gray = np.array([cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) for img in X])

# Extract HOG features
hog_features = []
for img in X_gray:
    features = hog(
        img,
        orientations=9,
        pixels_per_cell=(16,16),
        cells_per_block=(2,2),
        block_norm='L2-Hys'
    )
    hog_features.append(features)

hog_features = np.array(hog_features)
print("HOG features shape:", hog_features.shape)

We trained a Support Vector Machine (SVM) classifier on these features. ML achieved an accuracy of 74.29%.

# Initialize & train SVM
ml_model = SVC(kernel='rbf')
ml_model.fit(X_train, y_train)

# Predictions
ml_preds = ml_model.predict(X_test)

# Accuracy
ml_accuracy = accuracy_score(y_test, ml_preds)
print("Machine Learning Accuracy: {:.2f}%".format(ml_accuracy*100))

# Optional: Confusion matrix
cm = confusion_matrix(y_test, ml_preds)
print("Confusion Matrix:\n", cm)

Machine Learning Accuracy: 74.29%
Confusion Matrix:
 [[137  58]
 [ 41 149]]

The ML model does reasonably well, but its performance is limited by handcrafted features.

Deep Learning Approach

Next, we trained a Convolutional Neural Network (CNN) that can automatically learn features from the images. This CNN extracts petal shapes, textures, and subtle details that ML might miss.

import tensorflow as tf
from tensorflow.keras import layers, models

dl_model = models.Sequential([
    layers.Conv2D(32, (3,3), activation='relu', input_shape=(IMG_SIZE,IMG_SIZE,3)),
    layers.MaxPooling2D(2,2),

    layers.Conv2D(64, (3,3), activation='relu'),
    layers.MaxPooling2D(2,2),

    layers.Conv2D(128, (3,3), activation='relu'),
    layers.MaxPooling2D(2,2),

    layers.Flatten(),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(1, activation='sigmoid')  # binary classification
])

dl_model.summary()

We trained the CNN for 30 epochs with data augmentation. After evaluation, the DL model achieved 85.71% accuracy, much higher than ML.

Epoch 1/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 49s 1s/step - accuracy: 0.8056 - loss: 0.6186 - val_accuracy: 0.8961 - val_loss: 0.3063
Epoch 2/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 45s 1s/step - accuracy: 0.7519 - loss: 0.4839 - val_accuracy: 0.8929 - val_loss: 0.2516
Epoch 3/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 46s 1s/step - accuracy: 0.7734 - loss: 0.4461 - val_accuracy: 0.9286 - val_loss: 0.2301
Epoch 4/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 82s 1s/step - accuracy: 0.8113 - loss: 0.4200 - val_accuracy: 0.8961 - val_loss: 0.2441
Epoch 5/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 48s 1s/step - accuracy: 0.8309 - loss: 0.3724 - val_accuracy: 0.9253 - val_loss: 0.2124
Epoch 6/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 46s 1s/step - accuracy: 0.8378 - loss: 0.3800 - val_accuracy: 0.8636 - val_loss: 0.3138
Epoch 7/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 49s 1s/step - accuracy: 0.8483 - loss: 0.3569 - val_accuracy: 0.9156 - val_loss: 0.2071
Epoch 8/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 46s 1s/step - accuracy: 0.8589 - loss: 0.3541 - val_accuracy: 0.9318 - val_loss: 0.2196
Epoch 9/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 47s 1s/step - accuracy: 0.8877 - loss: 0.2699 - val_accuracy: 0.9253 - val_loss: 0.2291
Epoch 10/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 46s 1s/step - accuracy: 0.8797 - loss: 0.2974 - val_accuracy: 0.9253 - val_loss: 0.1862
Epoch 11/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 47s 1s/step - accuracy: 0.8735 - loss: 0.3012 - val_accuracy: 0.9091 - val_loss: 0.2100
Epoch 12/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 81s 1s/step - accuracy: 0.8671 - loss: 0.2905 - val_accuracy: 0.9318 - val_loss: 0.2048
Epoch 13/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 49s 1s/step - accuracy: 0.8845 - loss: 0.2824 - val_accuracy: 0.9188 - val_loss: 0.2141
Epoch 14/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 46s 1s/step - accuracy: 0.8760 - loss: 0.2807 - val_accuracy: 0.9481 - val_loss: 0.1933
Epoch 15/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 47s 1s/step - accuracy: 0.8828 - loss: 0.2720 - val_accuracy: 0.8831 - val_loss: 0.2699
Epoch 16/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 46s 1s/step - accuracy: 0.8917 - loss: 0.2562 - val_accuracy: 0.8994 - val_loss: 0.2205
Epoch 17/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 49s 1s/step - accuracy: 0.9075 - loss: 0.2298 - val_accuracy: 0.9058 - val_loss: 0.2410
Epoch 18/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 46s 1s/step - accuracy: 0.9200 - loss: 0.2157 - val_accuracy: 0.9351 - val_loss: 0.1972
Epoch 19/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 47s 1s/step - accuracy: 0.9239 - loss: 0.1891 - val_accuracy: 0.9123 - val_loss: 0.2217
Epoch 20/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 45s 1s/step - accuracy: 0.9130 - loss: 0.2367 - val_accuracy: 0.8766 - val_loss: 0.2751
Epoch 21/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 47s 1s/step - accuracy: 0.9105 - loss: 0.2186 - val_accuracy: 0.9221 - val_loss: 0.2224
Epoch 22/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 46s 1s/step - accuracy: 0.9146 - loss: 0.1949 - val_accuracy: 0.9188 - val_loss: 0.2191
Epoch 23/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 49s 1s/step - accuracy: 0.9288 - loss: 0.1793 - val_accuracy: 0.8994 - val_loss: 0.2418
Epoch 24/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 46s 1s/step - accuracy: 0.9088 - loss: 0.2447 - val_accuracy: 0.9091 - val_loss: 0.2558
Epoch 25/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 47s 1s/step - accuracy: 0.9203 - loss: 0.1905 - val_accuracy: 0.9188 - val_loss: 0.2165
Epoch 26/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 46s 1s/step - accuracy: 0.9444 - loss: 0.1624 - val_accuracy: 0.9123 - val_loss: 0.2458
Epoch 27/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 47s 1s/step - accuracy: 0.9347 - loss: 0.1750 - val_accuracy: 0.9318 - val_loss: 0.2091
Epoch 28/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 45s 1s/step - accuracy: 0.9213 - loss: 0.1778 - val_accuracy: 0.9091 - val_loss: 0.2497
Epoch 29/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 47s 1s/step - accuracy: 0.9247 - loss: 0.1981 - val_accuracy: 0.9221 - val_loss: 0.2465
Epoch 30/30
39/39 ━━━━━━━━━━━━━━━━━━━━ 46s 1s/step - accuracy: 0.9331 - loss: 0.1870 - val_accuracy: 0.9221 - val_loss: 0.2095

Comparison

Model	Accuracy
ML (HOG + SVM)	74.29%
DL (CNN + Augmentation)	85.71%

Results

Machine Learning AI model obtained an accuracy of 74.29%
Deep Learning AI model obtained an accuracy of 85.71%

that is a huge 11% increase in accuracy.

4 Reasons to spend more time with DL ❤️

Feature Engineering Limitations – ML needs handcrafted features, DL learns them automatically.
Scalability – DL scales better with large and complex datasets.
Pattern Recognition – DL captures subtle shapes and textures that ML may miss.
Modern Workflows – DL integrates seamlessly with images, audio, text, and end-to-end pipelines.

At the end of the day the ML is a machine. And has to be taught what is what and which is which . The DL model since its been inspired by the way the human brain works and uses Artificial Neurons to learn things rather than using a mathematical approach. In scenarios where images, videos are present the DL model surely shall bring about effective results.

The ML has to be told and taught what to do. DL recognizes patterns and learns things automatically.

Deep Learning surely wins over Machine Learning.

⭐️ Vishnu Ajit's Kaggle url

🛠️ Vishnu Ajit's Github url

Project - Supervised Learning with Python - Lets use Logistic Regression for Predicting the chances of having a Heart Attack

Vishnu Ajit — Sat, 18 Jan 2025 12:39:49 +0000

Excited to share my second tutorial along with the python notebook which i made for experimenting with machine learning algorithms! This time we are exploring a project using LogisticRegression . It loads the dataset from csv file (dataset obtained from kaggle) and enables us to predict probabilities of a patient having Heart Attack🧑‍💻📊

Concepts Used Include:

LogisticRegression🌀
StandardScaler from sklearn.preprocessing library 🎯
fit_transform() method ➖
train_test_split() 🌟
model.predict() 🔄
model.predict_proba() 🌟
classification_report() 🌟
roc_auc_score() 🎯

Why This Notebook:

The main goal of this notebook is to visually understand how to use the LogisticRegression concept in machine learning algorithm. Using the beauty of the Python programming language we try to predict from a patient's hospital data whether he might have a heart attack in the future.

I’ve included a line to my notebook to guide you through the it
The link to the notebook: https://github.com/ruforavishnu/Project_Machine_Learning/blob/master/project-supervised-learning-logistic-regression-heart-disease-prediction.ipynb

The link to the dataset : https://github.com/ruforavishnu/Project_Machine_Learning/blob/master/heart-disease-prediction.csv (Dataset obtained from kaggle)

Kaggle url to the same above given dataset : https://www.kaggle.com/datasets/dileep070/heart-disease-prediction-using-logistic-regression

What’s Next:

Over the Next week, I’ll be posting more of my notebooks for other concepts in Machine Learning as recommended by this url https://www.kaggle.com/discussions/getting-started/554563 [# Machine Learning Engineer Roadmap for 2025]
We'll especially be looking at Supervised Learning and Unsupervised Learning to get our feet wet before we begin to walk towards the shores of greater Artificial Intelligence.

Who's This For:

For anybody who loves python and who has been telling themselves I'm gonna learn Machine Learning one day. This is Day 2 for them ! Lets learn Machine Learning Together :) Yesterday we looked at Linear Regression. Today we are exploring the concept called Logistic Regression.

Feel free to explore the notebook and try out your own machine learning models! 🚀

The link to the notebook: https://github.com/ruforavishnu/Project_Machine_Learning/blob/master/project-supervised-learning-logistic-regression-heart-disease-prediction.ipynb

The link to the dataset : https://github.com/ruforavishnu/Project_Machine_Learning/blob/master/heart-disease-prediction.csv (Dataset obtained from kaggle)

Kaggle url to the same above given dataset : https://www.kaggle.com/datasets/dileep070/heart-disease-prediction-using-logistic-regression

Kaggle References: https://www.kaggle.com/discussions/getting-started/554563 [Machine Learning Engineer Roadmap for 2025]

Now Lets begin coding shall we? :)

Step 1.

Load the dataset from our csv file

import pandas as pd



data = pd.read_csv('heart-disease-prediction.csv')

print(data.head())

and we get the output

male  age  education  currentSmoker  cigsPerDay  BPMeds  prevalentStroke  \
0     1   39        4.0              0         0.0     0.0                0   
1     0   46        2.0              0         0.0     0.0                0   
2     1   48        1.0              1        20.0     0.0                0   
3     0   61        3.0              1        30.0     0.0                0   
4     0   46        3.0              1        23.0     0.0                0   

   prevalentHyp  diabetes  totChol  sysBP  diaBP    BMI  heartRate  glucose  \
0             0         0    195.0  106.0   70.0  26.97       80.0     77.0   
1             0         0    250.0  121.0   81.0  28.73       95.0     76.0   
2             0         0    245.0  127.5   80.0  25.34       75.0     70.0   
3             1         0    225.0  150.0   95.0  28.58       65.0    103.0   
4             0         0    285.0  130.0   84.0  23.10       85.0     85.0   

   TenYearCHD  
0           0  
1           0  
2           0  
3           1  
4           0

Step 2. Lets explore the data by ourselves first

We try running data.info() on our dataset

print(data.info())

and we get the output as

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4238 entries, 0 to 4237
Data columns (total 16 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   male             4238 non-null   int64  
 1   age              4238 non-null   int64  
 2   education        4133 non-null   float64
 3   currentSmoker    4238 non-null   int64  
 4   cigsPerDay       4209 non-null   float64
 5   BPMeds           4185 non-null   float64
 6   prevalentStroke  4238 non-null   int64  
 7   prevalentHyp     4238 non-null   int64  
 8   diabetes         4238 non-null   int64  
 9   totChol          4188 non-null   float64
 10  sysBP            4238 non-null   float64
 11  diaBP            4238 non-null   float64
 12  BMI              4219 non-null   float64
 13  heartRate        4237 non-null   float64
 14  glucose          3850 non-null   float64
 15  TenYearCHD       4238 non-null   int64  
dtypes: float64(9), int64(7)
memory usage: 529.9 KB
None

Step 3. Now what do we do with missing data?

What do we with columns in our dataset which have no value ?? and how do we do that ??


print(data.isnull().sum())

and we get the output


male                 0
age                  0
education          105
currentSmoker        0
cigsPerDay          29
BPMeds              53
prevalentStroke      0
prevalentHyp         0
diabetes             0
totChol             50
sysBP                0
diaBP                0
BMI                 19
heartRate            1
glucose            388
TenYearCHD           0
dtype: int64

Oh, so there are a couple of columns that have Null data or NaN values.

The fillna() method comes to rescue us.

data.fillna(data.mean(), inplace=True)

Hmmm, did that work? how do we check that? Oh ! Lets try running data.isnull().sum() once again?

print(data.isnull().sum())

and we get the output

male               0
age                0
education          0
currentSmoker      0
cigsPerDay         0
BPMeds             0
prevalentStroke    0
prevalentHyp       0
diabetes           0
totChol            0
sysBP              0
diaBP              0
BMI                0
heartRate          0
glucose            0
TenYearCHD         0
dtype: int64

Yes, it worked

Step 4. Now we need to preprocess the data don't we?

How do we do that? Lets see. Ok, so what all kinds of columns do we have ?

data.columns to the rescue

data.columns

and we get the output

Index(['male', 'age', 'education', 'currentSmoker', 'cigsPerDay', 'BPMeds',
       'prevalentStroke', 'prevalentHyp', 'diabetes', 'totChol', 'sysBP',
       'diaBP', 'BMI', 'heartRate', 'glucose', 'TenYearCHD'],
      dtype='object')

Ok, thats a lot of columns !! Kaggle has provided us with a lot of columns. We dont want all that do we?

Lets pick and choose.

['age', 'totChol','sysBP','diaBP', 'cigsPerDay','BMI','glucose']

Aha, now we build our friends. The only ones who have the keys to Logistic Regression. One is a DataFrame and the other is a Series.

Lets call them capital X and small y

X = data[['age', 'totChol','sysBP','diaBP', 'cigsPerDay','BMI','glucose']]

y = data['TenYearCHD']

Hmmm, lets see what we have now

X.head()

and we get the output

	age	totChol	sysBP	diaBP	cigsPerDay	BMI	glucose
0	39	195.0	106.0	70.0	0.0	26.97	77.0
1	46	250.0	121.0	81.0	0.0	28.73	76.0
2	48	245.0	127.5	80.0	20.0	25.34	70.0
3	61	225.0	150.0	95.0	30.0	28.58	103.0
4	46	285.0	130.0	84.0	23.0	23.10	85.0

Step 5: We need to normalize for better model performance

What is a standard scaler?

Simple explanation: A standard scaler is something that allows you to compare two items which are presently on different scales by bringing both of them to a similiar scale. So they can be compared against each other.

For example : Two friends are talking about how fast a Ferrari goes and how fast a Porsche goes. But one person is using the m/s scale and the other person is using the km/h scale. Its difficult to analyze which is faster right? So we convert both of them into either m/s or into km/h. So the comparison is easy enough.

And, Here comes the StandardScaler to our rescue

from sklearn.preprocessing import StandardScaler


scaler = StandardScaler()

X = scaler.fit_transform(X)

Step 6: Now we need to split the data we have into 2 segments.

First segment is for training the machine learning model. Second segment is to test the machine learning model we trained using the first segment to really check whether the model did work.

Simple explanation: Kind of like asking a student who learnt using only one textbook , the questions from another textbook . Just to check if the student really understood the concept or has he just byhearted the whole thing.

And, How do we do that? By using train_test_split()

from sklearn.model_selection import train_test_split



X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Note we have used test_size parameter to load only 20% (0.2 means 20%) of the available data for testing data. That means the remaining 80% is given as training data.

At the end of successful completion of the train_test_split we get 4 variables

X_train : has the training data. it has 80% elements from our Dataframe X (remember capital letter X?)
X_test : has the testing data. it has 20% elements from our Dataframe X
y_train: has the training data. has the 80% elements from our Series y (remember small letter y? )
y_test : has the testing data. has 20% elements from our Series y

Step 7. Finally we arrive at our final milestone. Training the LogisticRegression model

Lets train our model using LogisticRegression. (That is technical lingo for saying lets use the power of machine learning along with the beautiful python programming language to create an Artificial Intelligence model. An AI model that can predict what we want it to predict)

How do we do that? Oh just three lines of code :) 🤯🤯

from sklearn.linear_model import LogisticRegression


model = LogisticRegression()

model.fit(X_train, y_train)

Oh you can sit and pause. Its alright. That is it. Just 3 lines of code in python. And we have created an Artificial Intelligence model for ourselves. Ain't it a beauty?? 💛 💛

Step 8. Lets evaluate the machine learning model we just created

We save the values of the prediction to a variable called y_pred.

y_pred = model.predict(X_test)

We need to evaluate our model.

We use two methods for that

classification_report()
roc_auc_score()

Lets run that

from sklearn.metrics import classification_report , roc_auc_score



print(classification_report(y_test, y_pred))

print('ROC-AUC-score:', roc_auc_score(y_test, model.predict_proba(X_test)[:, 1]))

and we get the output as


        precision    recall  f1-score   support

           0       0.86      0.99      0.92       724
           1       0.55      0.05      0.09       124

        accuracy                           0.85       848

macro avg       0.70      0.52      0.51       848
weighted avg       0.81      0.85      0.80       848

ROC-AUC-score: 0.695252628764926

Step 9. We are done. The project is over. 💯✅✅Tada.

Lets test the machine learning model we created with a real person's data shall we?

patient2 = [[45, 210, 130, 85, 10, 25.1, 95]]

patient2_df = pd.DataFrame(patient2, columns=['age','totChol', 'sysBP','diaBP', 'cigsPerDay', 'BMI','glucose'])

patient2_scaled = scaler.transform(patient2_df)

We give the model our scaled data. and store the data in a variable called prediction.

prediction = model.predict(patient2_scaled)

Finally, lets test it using our old fashioned print() statement? ✅✅

# 1=Heart Disease, 0=No Heart Disease



if prediction[0] == 1:

    print('The chances the patient might have a heart disease in the future is: True')

else:

    print('The chances the patient might have a heart disease in the future is: False')

and we get the output

The chances the patient might have a heart disease in the future is: True

And it feels beautiful to know that we have completed learning one more machine learning concept doesn't it? :) 💯✅✅

Yes, it does 💛 💛

Homework: Now, here are a few other patient data for you to check on your own.

patient3 = [[65, 250, 155, 100, 15, 32.0, 150]]

patient4 = [[55, 240, 140, 90, 10, 29.5, 110]]

patient5 = [[70, 300, 160, 105, 20, 34.0, 180]]

Now go! 💨 🏃🏃 Go, open Visual Studio Code and start coding 🤖🤖. And, don't forget to come back here tomorrow for our next project. Like somebody once said: You never know what the tide might bring tomorrow? 🌊 🔮🖥️

Posting my first Dev Post: Project : Using Linear Regression in Machine Learning to predict house prices

Vishnu Ajit — Fri, 17 Jan 2025 12:25:59 +0000

Posting My First Dev Post Notebook: Predicting house prices using LinearRegression

Excited to share my notebook which i made for experimenting with machine learning algorithms! This notebook contains code and markdown for a project using LinearRegression . It loads the dataset from load_boston dataset and enables us to predict house prices from the available actual houseprices 🧑‍💻📊

Concepts Used Include:

Train_Test_Split🌀
LinearRegression 🎯
mean_squared_error ➖
model.coef_ 🌟
model.intercept_ 🔄
model.predict 🌟

Why This Notebook:

The main goal of this notebook is to visually understand how to use the LinearRegression concept in machine learning algorithm to calculate/predict house prices from the training data we have.

I’ve included a line to my notebook to guide you through the it https://colab.research.google.com/drive/1-fGYNuGfMXjq172ErX7TWGoSPguU863f?usp=sharing

What’s Next:

Who's This For:

For anybody who loves python and who has been telling themselves I'm gonna learn Machine Learning one day. This is for them !Lets learn Machine Learning Together :)

Feel free to explore the notebook and try out your own machine learning models! 🚀

Notebook Link: https://colab.research.google.com/drive/1-fGYNuGfMXjq172ErX7TWGoSPguU863f?usp=sharing [Project ML - Learn Linear Regression in Machine Learning through Python]
Kaggle References: https://www.kaggle.com/discussions/getting-started/554563 [Machine Learning Engineer Roadmap for 2025]