Implementing Linear Regression with Gradient Descent in Python

Over the past weeks I’ve been revisiting the fundamentals of Machine Learning. In my previous posts, I focused on: - Linear Regression (prediction, cost function, gradient descent) - Extending the model with multiple features, vectorization, feature scaling, and polynomial regression To consolidate these concepts, I built a House Price Predictor from scratch using Python and NumPy. The goal was not just to make predictions, but to connect the theory with an actual implementation. This project allowed me to revisit and integrate: - supervised learning with input features (X) and target values (y) - linear regression for continuous prediction - the prediction function f(w, b)(x) - the cost function as a measure of error - gradient descent as an optimization process - multiple features and their impact on the model - vectorization using NumPy - feature scaling and its effect on convergence - polynomial features to model non-linear relationships One of the most interesting parts was visualizing the cost function as contour lines and observing how gradient descent moves toward the minimum. This made the optimization process much more concrete. You can explore the full project here: https://lnkd.in/d6g_m-9W Rendered version: https://lnkd.in/d2ZRUN6s This is part of a broader effort to move from understanding concepts to actually building them from scratch. #MachineLearning #Python #NumPy

Built Logistic Regression From Scratch — Achieving ~93% Accuracy Recently, I implemented a Logistic Regression classifier entirely from scratch using Python and NumPy, without relying on any machine learning libraries. The goal was to deeply understand how the algorithm actually works under the hood rather than treating it as a black box. The model was trained using stochastic gradient descent. The dataset was first shuffled and split into training and testing sets. Feature scaling was applied using standardization so that all features contribute proportionally during optimization. At the core of the model is the sigmoid function, which transforms the linear combination of features into a probability score between 0 and 1. For each training sample, the algorithm computes the predicted probability, compares it with the true label, and adjusts the model weights using gradient descent to reduce the prediction error. This iterative process allows the model to gradually learn the optimal decision boundary separating the two classes. Instead of updating weights after processing the entire dataset, stochastic updates were applied sample-by-sample, enabling faster learning and improved convergence. Key components of the implementation: Dataset shuffling and a 70/30 train–test split Feature standardization using training statistics Sigmoid-based probability estimation Stochastic gradient descent weight updates Binary classification using a 0.5 probability threshold Evaluation on unseen test data The model achieved an accuracy of 0.929 (approximately 93%) on the test set, demonstrating that even a fully custom implementation can perform competitively when the mathematical foundations are applied correctly. This exercise reinforced the importance of understanding the mathematical intuition behind machine learning algorithms. Building models from scratch provides clarity on optimization, probability estimation, and how learning actually occurs inside the algorithm. Next step: extending this implementation with regularization, bias terms, and more advanced optimization strategies. GitHub Link: https://lnkd.in/gCN_7sBt #MachineLearning #LogisticRegression #Python #NumPy #AI #DataScience #FromScratch Dr. Jagdish Chandra Patni Dr. Suneet K. Gupta Bhupaesh Ghai Krish Naik

Most tutorials tell you to trust the math behind gradient descent. I didn't. I derived it from scratch on a whiteboard, implemented it in NumPy, and tested it on real data. Here's what I found: https://lnkd.in/ek5YdBMD #MachineLearning #Python #DataScience

🚀 Exploring Machine Learning classification with Decision Trees! In this quick walkthrough, I'm using Python and Scikit-learn to build and evaluate a DecisionTreeClassifier. It's always great to revisit the fundamentals and get hands-on with classic datasets like the Titanic survival data. 🚢 Here is a quick look at my workflow: 🧹 Data Preprocessing: Dropping unnecessary features, handling missing values, and converting categorical data into numerical data using LabelEncoder. ✂️ Data Splitting: Using train_test_split to ensure the model is evaluated on unseen data. 🌳 Model Training: Fitting the Decision Tree to the training set, checking the accuracy score, and making predictions! Building a strong foundation in these core ML concepts is key to tackling more complex AI challenges. What’s your go-to algorithm for classification tasks? Let me know in the comments! 👇 #MachineLearning #DataScience #Python #ScikitLearn #ArtificialIntelligence #DecisionTrees

#Day 9 of 365: Meet the Engine of AI (NumPy) 🏎️🔢 In Machine Learning, we don't just deal with one or two numbers. We deal with millions of them—all at once. If you tried to do this with standard Python lists, your computer would crawl. That’s why we use NumPy (Numerical Python). What is NumPy? It’s a library that introduces the Array. Think of an array as a super-powered list that allows you to perform math on every single item inside it simultaneously. The "Row of Lockers" Analogy: Standard Python: Like a single person opening one locker at a time, checking the contents, and moving to the next. 🚶♂️ NumPy: Like a row of 100 lockers where every door opens at the exact same time with a single command. 🔓🔓🔓 Why it matters: Deep Learning and Image Recognition (like FaceID) are just massive amounts of array math. Without NumPy, the "AI Revolution" would be too slow to actually use. The Interactive Part: Imagine you have a list of 1,000 house prices and you want to increase them all by 10%. In plain English, would you rather: A) Write a "Loop" to change each price one by one? B) Tell the computer "Prices * 1.1" and have it done instantly? Drop your vote below! (Hint: Data Scientists are notoriously lazy—we always pick B). 😉 #365DaysOfML #DataScience #NumPy #Python #Day9 #Coding #ArtificialIntelligence #TechTips

Starting my journey into AI & Machine Learning I completed my first data analysis project using Python. In this project, I built a script that: ✅ Loads a CSV dataset ✅ Calculates Mean, Median, Mode and Standard Deviation ✅ Visualizes data distribution using a histogram This experience helped me understand an important lesson — before building Machine Learning models, understanding data statistically is essential. Tools & Technologies: • Python • Pandas • NumPy • Matplotlib • Git & GitHub Through this project, I learned how data analysis forms the foundation of AI systems. 🔗 Project available on GitHub: https://lnkd.in/g_-ZPRdb Next step is deeper exploration into data preprocessing and machine learning concepts. #Python #DataScience #MachineLearning #AI #LearningJourney #GitHub #BeginnerToEngineer

Machine Learning: Predicting Scores Using Linear Regression I recently practiced building a simple machine learning model using Scikit-learn to understand how different factors influence a score. In this experiment, I used Linear regression to predict the score based on two features: • Hours • Sleep 🔧 Steps in the Workflow 1️⃣ Loaded the dataset using Pandas 2️⃣ Defined input features (Hours, Sleep) and target variable (Score) 3️⃣ Split the dataset into training and testing sets using train_test_split 4️⃣ Trained a Linear Regression model 5️⃣ Predicted results on the test dataset 6️⃣ Evaluated model performance using R² Score 📈 What I Learned • How train-test splitting helps prevent overfitting • How linear regression identifies relationships between variables • How to evaluate a model using performance metrics like R² 🛠 Tools Used Python | Pandas | Scikit-learn | Machine Learning This small exercise helped me better understand the fundamentals of regression modeling and model evaluation. Excited to keep building more ML and data analysis projects. #Python #MachineLearning #DataScience #ScikitLearn #DataAnalytics #LearningJourney #Jobs #Hiring

🚀 Day 6 of My 30-Day AI/ML Challenge: Real Estate Price Predictor (Linear Regression and Ridge Regression) Today, I built a Machine Learning-based Real Estate Price Predictor that estimates property prices using Linear Regression and Ridge Regression models. This project focuses on understanding regression techniques, feature scaling, and how regularization improves generalization in predictive modeling. 🏠 What the project does: 1.Predicts property prices based on housing features 2.Compares Linear Regression and Ridge Regression 3.Applies StandardScaler for feature normalization 4.Converts predictions into INR (₹ Lakhs) for better interpretation 5.Provides a clean, interactive web interface using Streamlit 🛠 Tech Stack: Python | Scikit-learn | Streamlit | NumPy | Pandas 📊 Key Concepts Applied: -Supervised Learning (Regression) -Train-Test Split -Feature Scaling -Model Regularization (Ridge) -Model Evaluation using RMSE & R² -Converting ML scripts into a deployable web app One of the key learnings was understanding how Ridge Regression helps reduce overfitting by penalizing large coefficients, leading to better generalization. The project also reinforced how important data preprocessing and scaling are in building stable predictive models. While this is a demonstration project (trained on a standard dataset), it showcases how ML can be integrated into real-world applications like property price estimation. 🔗Git Repository Link: https://lnkd.in/gpFkBF2j Excited to keep building and improving every single day 🚀 #MachineLearning #Regression #Streamlit #Python #DataScience #ArtificialIntelligence #AIProjects #BuildInPublic #30DayChallenge #RealEstateTech #ScikitLearn #SoftwareEngineering #MLProjects

📘 Day 4 of Machine Learning — Introduction to Regression Today I studied regression — a supervised learning technique for predicting continuous outcomes like prices or measurements. The goal of regression is to find a relationship between input features (like house size or BMI) and a target variable (like price or blood glucose), to understand how changes in features affect the outcome. 🔬 Practical: Predicting Blood Glucose Levels Here's exactly what I coded today, step by step: 1️⃣ Loading the data python import pandas as pd diabetes_df = pd.read_csv("diabetes.csv") print(diabetes_df.head()) 2️⃣ Creating Feature & Target Arrays python X = diabetes_df.drop("glucose", axis=1).values Y = diabetes_df["glucose"].values 3️⃣ Selecting a single feature (BMI) & reshaping python X_bmi = X[:, 3] X_bmi = X_bmi.reshape(-1, 1) # scikit-learn requires 2D arrays! # Shape: (752, 1) ✅ 4️⃣ Visualizing BMI vs. Glucose — confirmed a clear positive trend 📈 5️⃣ Fitting Linear Regression python from sklearn.linear_model import LinearRegression reg = LinearRegression() reg.fit(X_bmi, Y) predictions = reg.predict(X_bmi) 6️⃣ Plotting the line of best fit on the scatter plot ✅ 💡 Biggest lesson today: Scikit-learn won't accept 1D arrays as features — always .reshape(-1, 1) before fitting your model! Notes below 👇 #MachineLearning #Python #DataScience #LinearRegression #ScikitLearn #100DaysOfCode #LearningInPublic #Day4