Forem: MohammadReza Mahdian

Decision Tree vs KNN: The No-BS Truth Every Developer Needs to Know (3-Minute Read)

MohammadReza Mahdian — Fri, 28 Nov 2025 07:15:37 +0000

Decision Tree vs KNN – A no-BS comparison

For a quick overall comparison between Decision Tree and KNN, we just need to know this:

KNN works based on the distance between points
Decision Tree learns “where and under what condition this happened” and right there builds a chain of if-else and branches out

From this simple explanation we can already tell:

KNN has basically zero training time → it just stores the data
Decision Tree has training time → it measures, creates conditions, branches → training time is usually higher

After training:

Decision Tree only has a few conditions → low memory usage
KNN keeps all the training data → much higher RAM usage

Prediction (inference) time:

Decision Tree → passes the data through a few conditions → usually fast
KNN → has to calculate distance to all data points again → slower

Sensitivity to scale:

KNN works with distances → super sensitive to feature scales (you absolutely have to normalize)
Decision Tree → doesn’t care at all

Interpretability:

Decision Tree → you can draw the tree and see exactly why it gave that answer → completely interpretable
KNN → just says “it was closer to these” → basically no interpretability

Sensitivity to noise:

KNN looks at local density → noise destroys its accuracy very easily
Decision Tree can also overfit to noise if you don’t prune or limit depth, but with proper pruning and settings it becomes much more robust

Summary – when is which one better:

Small to medium dataset + training speed matters more + we don’t need interpretability → KNN is good
Large dataset + we want fast predictions + we want interpretability → Decision Tree is usually the better choice

By nature KNN is lazy and learns nothing, just measures distances

Decision Tree sits down, thinks, and finds its own paths

This is exactly my view on Decision Tree vs KNN.

If you found this helpful, here are my other ML QuickTips:
https://github.com/PyRz-Tech/PyRz-Tech/blob/main/quick-tips/machine-learning/README.md

Which one do you use more? Drop it in the comments 👇

Why everyone fails at the California Housing dataset the same way(6 brutal reasons)

MohammadReza Mahdian — Mon, 24 Nov 2025 21:41:21 +0000

Why You’ll Never Build a Strong Model with the 9 Raw Features of the California Housing Dataset (6 Key Insights)

A 5-minute analysis of the California housing dataset

A while back, I reopened the famous California housing dataset and looked at it from scratch — no solutions, no notebooks, just the raw data and my own eyes.
These are the 9 features we all know:

'longitude',
'latitude',
'housing_median_age',
'total_rooms',
'total_bedrooms',
'population',
'households',
'median_income',
'ocean_proximity'

Here are the six things that actually matter (and that most people miss):

Latitude and longitude alone tell you almost nothing. Any single coordinate has a massive spread in prices — you can’t rely on them as-is.
Median house age has the same issue: huge variance at every age level. By itself, it barely helps the model.
Total rooms and bedrooms obviously correlate with luxury, but they’re heavily correlated with each other. What actually matters is their ratio to each other and especially to the number of households.
Population and households follow very similar patterns — except in high-price areas where density drops (because wealthy households are fewer), in middle-class urban zones both rise together, and in very crowded areas, prices fall again despite high density.
Median income is extremely important, but if you don’t combine it properly with population or households, it can mislead you badly. A small block of very high earners can have higher total income than a much larger middle-income area — causing the model to overpredict prices.
Distance from the ocean (or ocean proximity) alone creates another huge circle of varying prices. It’s not sufficient on its own.

if you just throw these 9 raw features into a model, you won’t get anything impressive.

But if you actually combine them intelligently and create a few meaningful new features using only these same columns, your model’s performance jumps significantly — almost instantly.

If you’d like, let me know in the comments and I’ll build and share a set of powerful new features derived purely from these 9 original ones.

If there’s enough interest, I’ll post the full version next week.

follow me:
GitHub

Occam’s Razor destroyed my polynomial model in 5 minutes

MohammadReza Mahdian — Mon, 24 Nov 2025 02:11:46 +0000

I keep seeing people add higher-degree polynomials “just in case”.
Today I got tired of it and built the simplest possible counter-example.
Result: the quadratic model literally got a lower test R² than plain linear regression.
Let’s watch Occam’s Razor do its thing.

More complex model ≠ better model

(That’s literally Occam’s Razor in action)

A simple, reproducible example showing why a more complex model is not always better — even on perfectly linear data.

Today I created a perfectly linear dataset:

y = 2x + 3 + some random noise

Then I trained two models:

Simple Linear Regression → Test R² ≈ 0.8626
Polynomial Degree 2 (more complex) → Test R² ≈ 0.8623

Guess what?

The complex model did slightly better on training data…

but performed worse (or at best equal) on unseen test data.

This notebook walks through the entire experiment — step by step — with clean plots and real numbers.

It’s a classic illustration of overfitting and why Occam’s Razor matters in machine learning.

Let’s dive in.

1. Import Libraries & Generate Synthetic Linear Data with Noise

We generate a perfectly linear dataset based on the true relationship y = 2x + 3.

Then we add Gaussian noise to scatter the points slightly off the line — just like real-world data.

Why add noise?

Because in practice, data is never perfectly clean.

This noise tempts the polynomial model to fit random fluctuations instead of the underlying pattern — classic overfitting.

Meanwhile, the simple linear model ignores the noise and captures only the true signal.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.metrics import r2_score

Generate perfectly linear data with noise

x = np.arange(-5.0, 5.0, 0.1)
y_true = 2 * x + 3
y_noise = 2 * np.random.normal(size=x.size)
y = y_true + y_noise

Plot: Data + True Relationship

plt.figure(figsize=(10, 6))
plt.scatter(x, y, marker='o', color='blue', alpha=0.7, s=50, label='Observed Data', edgecolor='navy', linewidth=0.5)
plt.plot(x, y_true, color='red', linewidth=3, label='True Relationship (y = 2x + 3)')

plt.title('Synthetic Dataset with Ground Truth', fontsize=14, pad=15)
plt.xlabel('x')
plt.ylabel('y')

plt.legend(loc='lower center', bbox_to_anchor=(0.5, -0.15), ncol=2, fancybox=True, shadow=True, fontsize=11)

plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

2. Convert to DataFrame & Train/Test Split

We convert the data into a pandas DataFrame for easier handling and cleaner syntax (e.g., df['x'] instead of indexing arrays).

Then we randomly split it into training (80%) and testing (20%) sets.

This split is crucial — it allows us to evaluate how well each model generalizes to unseen data, which is exactly where overfitting reveals itself.

X = x.reshape(-1, 1)
data = np.column_stack((x, y))
df = pd.DataFrame(data, columns=['x', 'y'])
msk = np.random.rand(len(df)) < 0.8
train = df[msk]
test = df[~msk]

train_x = train[['x']]
train_y = train[['y']]
test_x = test[['x']]
test_y = test[['y']]

3. Simple Linear Regression

We fit a basic linear model and evaluate it on the test set.

reg_linear = LinearRegression()
reg_linear.fit(train_x, train_y)

coef_linear = reg_linear.coef_[0]
intercept_linear = reg_linear.intercept_

pred_linear = reg_linear.predict(test_x)
r2_linear = r2_score(test_y, pred_linear)

print(f"r^2 SimpleRegressionLinear : {r2_linear:.4f}")
print(f"coef_ : {coef_linear}")

r^2 SimpleRegressionLinear : 0.8626
coef_ : [2.03889206]

plt.figure(figsize=(10, 6))
plt.scatter(df.x, df.y, color='blue', marker='o', alpha=0.7, s=50, label='Observed Data', edgecolor='darkblue', linewidth=0.5)

plt.plot(df.x, intercept_linear + coef_linear * df.x, color='red', linewidth=2.5, label='Linear Regression')

plt.title('Simple Linear Regression', fontsize=14, pad=15)
plt.xlabel('x')
plt.ylabel('y')

plt.legend(loc='lower center', bbox_to_anchor=(0.5, -0.15), ncol=2, fancybox=True, shadow=True, fontsize=11)

plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

4. Polynomial Regression (Degree 2)

Now we increase model complexity by adding x² as a feature using PolynomialFeatures.

poly = PolynomialFeatures(degree=2)
poly_train_x = poly.fit_transform(train_x)
poly_test_x = poly.transform(test_x)

poly_train_x = poly.fit_transform(train_x)
poly_test_x = poly.fit_transform(test_x)

reg_poly = LinearRegression()
reg_poly.fit(poly_train_x, train_y)

poly_test_y_poly = reg_poly.predict(poly_test_x)
r2_poly = r2_score(test_y, poly_test_y_poly)

coef_poly = reg_poly.coef_[0]
intercept_poly = reg_poly.intercept_

print(f"r^2 PolynomialRegressionLinear : {r2_poly:.4f}")
print(f"coef_ : {coef_poly}")

‍‍

r^2 PolynomialRegressionLinear : 0.8623
coef_ : [0.         2.03959043 0.00316868]

5. Final Comparison & Overfitting Detection

We compare both models side-by-side. Notice how the polynomial model fits the training noise slightly better — but performs worse on test data.

print(f"performance simple linear regression on train data : {reg_linear.score(train_x, train_y):.4f}  and test data: {reg_linear.score(test_x, test_y):.4f}")
print(f"performance poly linear regression on train data : {reg_poly.score(poly_train_x, train_y):.4f}  and test data: {reg_poly.score(poly_test_x, test_y):.4f}")

performance simple linear regression on train data : 0.8926  and test data: 0.8626
performance poly linear regression on train data : 0.8926  and test data: 0.8623

plt.figure(figsize=(10, 6))
plt.scatter(df.x, df.y, color='blue', marker='o', alpha=0.7, label='Observed Data')
plt.plot(df.x, intercept_linear + coef_linear * df.x, color='red', linewidth=2.5, label='Linear Regression')
plt.plot(df.x, intercept_poly + coef_poly[1] * df.x + coef_poly[2] * np.power(df.x, 2), color='green', linewidth=2.5, label='Polynomial Degree 2')
plt.title('Linear vs Polynomial Regression')
plt.xlabel('x')
plt.ylabel('y')
plt.legend(loc='lower center', bbox_to_anchor=(0.5, -0.15), ncol=3, fancybox=True, shadow=True)
plt.grid(True, alpha=0.3)
plt.xlim(-5, 5)
plt.tight_layout()
plt.show()

Conclusion

The true relationship is perfectly linear
The polynomial model (more complex) slightly overfits the training noise
The simpler linear model achieves better generalization on test data
This demonstrates Occam's Razor: Among models with similar explanatory power, prefer the simpler one

Less is often more in machine learning.

The Regression Coefficient Was Positive… Until I Added One Variable and It Flipped Negative

MohammadReza Mahdian — Sun, 23 Nov 2025 23:54:36 +0000

Why a Regression Coefficient Can Turn Negative When the Bivariate Relationship Is Clearly Positive

One plot that instantly breaks every intuition you had about regression coefficients.

Take a good look at that green line sloping down.

That single line is the clearest proof you’ll ever see that regression coefficients can lie — beautifully — when multicollinearity is severe.

Why Can a Coefficient Become Negative in Multiple Linear Regression

When Its Bivariate Relationship Is Clearly Positive?

One of the deepest and most frequently misunderstood concepts in multiple linear regression:

The regression coefficient is not the simple bivariate slope.
It is the partial effect of that variable while holding all other predictors constant.

When severe multicollinearity exists, "holding all other predictors constant" becomes a counterfactual — often physically impossible — scenario. In such cases, the sign of the coefficient can completely reverse.

We demonstrate this using the classic Canadian FuelConsumptionCo2 dataset.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score
import warnings
warnings.filterwarnings('ignore')

%matplotlib inline

Load the dataset

df = pd.read_csv("/home/pyrz-tech/Desktop/MachineLearning/FuelConsumptionCo2.csv")
df.head()

Select features and target

features = ['ENGINESIZE', 'CYLINDERS', 'FUELCONSUMPTION_COMB',
            'FUELCONSUMPTION_CITY', 'FUELCONSUMPTION_HWY']
target = 'CO2EMISSIONS'

X = df[features]
y = df[target]

Train/test split

np.random.seed(42)
msk = np.random.rand(len(df)) < 0.8
train = df[msk]
test = df[~msk]

print(f"Train size: {len(train)}, Test size: {len(test)}")

Train size: 848, Test size: 219

Fit multiple linear regression

reg = LinearRegression()
reg.fit(train[features], train[target])

print("Coefficients:", reg.coef_.round(3))
print("Intercept:   ", reg.intercept_.round(3))

Coefficients: [ 10.962   7.25  -10.937  12.227   8.104]
Intercept:    65.076

Model performance

pred = reg.predict(test[features])
r2 = r2_score(test[target], pred)
print(f"R² on test set: {r2:.4f}")

R² on test set: 0.8712

The diagnostic plot that reveals everything

plt.figure(figsize=(13, 8))

colors = ['blue', 'orange', 'green', 'red', 'purple']
labels = features

for i, col in enumerate(features):
    plt.scatter(test[col], test[target], color=colors[i], alpha=0.6, label=labels[i])

# The magic (technically "wrong") line that draws the exact multivariate coefficients
plt.plot(test[features].values,
         reg.coef_ * test[features].values + reg.intercept_,
         linewidth=3)

plt.xlabel('Feature value', fontsize=12)
plt.ylabel('CO₂ Emissions', fontsize=12)
plt.title('Each line = exact partial effect of that feature in the multivariate model', fontsize=14)
plt.legend()
plt.grid(alpha=0.3)
plt.show()

Why the sign reversal happens

The three fuel consumption variables are nearly perfectly collinear:

FUELCONSUMPTION_COMB ≈ 0.55 × CITY + 0.45 × HWY

In real data, you almost never observe a change in CITY or HWY while COMB stays fixed.

The regression coefficient for HWY answers the question:

"What happens to CO₂ if I increase HWY while holding COMB, CITY, and all other variables constant?"

That scenario is physically almost impossible → the coefficient becomes negative purely as a mathematical compensation mechanism.

This is known as sign reversal due to severe multicollinearity (or the suppressor effect).

Key takeaways

High R² + unexpected coefficient signs → almost always severe multicollinearity
In severe multicollinearity, coefficients lose causal interpretability
The plot above is one of the clearest diagnostic and teaching tools for this phenomenon

From now on, whenever you see a coefficient with the “wrong” sign, don’t argue.

Just draw this plot.

The discussion ends in 5 seconds.
If this just saved you hours of confusion, hit that ❤️ — it helps more people find it!

How I Built a 140 FPS Real-Time Face Landmark App with Just YOLOv9 + MediaPipe (5-Part Series)

MohammadReza Mahdian — Sun, 23 Nov 2025 20:53:53 +0000

A fast, clean, production-ready face detection + detailed facial landmark pipeline built from scratch in pure Python.

Runs at 120–140 FPS on a regular laptop (no dedicated GPU needed).

All 5 parts are now live. Finish the whole series in ~2 hours and walk away with a complete, real-time app.

Series Contents

Part	Title	Link
1	Project Setup & Clean Architecture	Part 1 →
2	ConfigModel – Load YOLO Only Once	Part 2 →
3	OpenCVBase – Eliminate Duplicate Code	Part 3 →
4	YOLOv9 + MediaPipe FaceMesh (539 refined landmarks)	Part 4 →
5	Final Rendering + Complete Real-Time App	Part 5 →

Full Source Code → GitHub
Demo → LinkedIn

Tech Stack

Python 3.11+
Ultralytics YOLOv9t-face (lindevs model)
MediaPipe FaceMesh with refine_landmarks=True
Pure OpenCV (no heavy extra dependencies)

Why this series stands out

Zero code duplication
Models loaded only once → maximum FPS
Fully modular OOP design – extend in minutes
Perfect portfolio / resume / startup prototype project

Prerequisites: Basic Python + some OpenCV knowledge (Part 1 covers the rest).

If you enjoyed this series — star the repo, give this post 50 claps (really helps!), and follow for more production-grade computer vision content.

Simple Linear Regression in Python – From Zero to 87% Accuracy in 10 Minutes

MohammadReza Mahdian — Sat, 22 Nov 2025 14:33:15 +0000

Loading the Required Packages

To proceed with reading the data, performing numerical operations, and visualizing relationships, we need the following libraries:

pandas – for reading and handling CSV files
numpy – for working with arrays and numerical transformations
matplotlib – for plotting and visual exploration of the data

Installation (run once):

pip install pandas numpy matplotlib

Dataset Introduction – The Classic Advertising Dataset

This is the famous Advertising dataset from the book Introduction to Statistical Learning (ISLR).

All monetary values are in thousands of dollars
TV – advertising budget spent on television
Radio – advertising budget spent on radio
Newspaper – advertising budget spent on newspapers
Sales – actual sales (target variable)

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

Level 2: Loading and Initial Inspection of the Dataset

Loading the Dataset

Reads the CSV file and stores it in a pandas DataFrame called df.

(If your file has a different name or path, adjust the string accordingly.)

df = pd.read_csv("/home/pyrz-tech/Desktop/MachineLearning/advertising.csv")

Preview the First Rows

‍df.head()Displays the first 5 rows of the DataFrame, allowing a quick visual verification of the loaded data.

df.head()

Dataset Dimensions

df.shape Returns the total number of rows and columns in the dataset.

df.shape

(200, 4)

Column Information

df.info() Shows column names, data types, non-null counts, and memory usage.

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 200 entries, 0 to 199
Data columns (total 4 columns):
 #   Column     Non-Null Count  Dtype  
---  ------     --------------  -----  
 0   TV         200 non-null    float64
 1   Radio      200 non-null    float64
 2   Newspaper  200 non-null    float64
 3   Sales      200 non-null    float64
dtypes: float64(4)
memory usage: 6.4 KB

Descriptive Statistics

df.describe() Provides summary statistics (count, mean, std, min, quartiles, max) for numerical columns.

df.describe()

Quick Summary of What We’ve Seen So Far

After running the basic checks, we confirmed:

Shape: 200 rows × 4 columns
All feature columns (TV, Radio, Newspaper) and the target (Sales) are of type float64
No missing values

Visual Inspection of Individual Feature–Sales Relationships

We now carefully examine the relationship between each advertising channel and Sales using individual scatter plots with regression lines. The goal is to visually assess:

Strength of the linear relationship
Density and spread of points around the fitted line
Which feature appears to have the strongest and most compact linear relationship with Sales

Visual Inspection Using Matplotlib’s scatter() Method

We now plot the relationship between each advertising feature and Sales using pure matplotlib.scatter() (no seaborn regplot) so that we can fully control the appearance and clearly see the raw data points.

plt.scatter(df.TV, df.Sales)

plt.scatter(df.Radio, df.Sales)

plt.scatter(df.Newspaper, df.Sales)

Visual Analysis Summary and Feature Selection for Simple Linear Regression

As observed in the scatter plots above:

All three advertising channels (TV, Radio, Newspaper) show a positive relationship with Sales.
The TV advertising budget exhibits the strongest, most densely clustered, and clearest linear relationship with Sales.
The TV feature has the steepest slope, the tightest spread around the trend, and the fewest apparent outliers.

Therefore, based on visual inspection and exploratory analysis, we select TV as the single predictor variable for our Simple Linear Regression model.

Selected Feature

Feature: TV

Target: Sales

Creating a Clean Subset for Focused Analysis

To work more cleanly and concentrate only on the selected feature (TV) and the target (Sales), we create a new DataFrame called cdf (clean DataFrame) containing just these two columns.

From now on, we will perform all subsequent steps (visualization, modeling, evaluation) using cdf instead of the full df. This keeps our workspace focused and readable.

cdf = df[['TV', 'Sales']]

Train-Test Split (Manual Random Split)

We now split the clean dataset (cdf) into training and test sets using a simple random mask.

Approximately 80 % of the data will be used for training and the remaining 20 % for testing.

This is a common manual approach when we want full control over the splitting process without importing train_test_split from scikit-learn.

train and test DataFrames are ready for model training and evaluation.

msk = np.random.rand(len(cdf)) < 0.8
train = cdf[msk]
test = cdf[~msk]

print(f'msk => {msk[:4]} ...')
print(f'train => {train.head()}')
print('...')
print(f'test => {test.head()} ...')
print('...')
print(f'len(train) => {len(train)}')
print(f'len(test) => {len(test)}')

msk => [ True  True  True False] ...
train =>       TV  Sales
0  230.1   22.1
1   44.5   10.4
2   17.2   12.0
5    8.7    7.2
6   57.5   11.8
...
test =>        TV  Sales
3   151.5   16.5
4   180.8   17.9
8     8.6    4.8
9   199.8   15.6
10   66.1   12.6 ...
...
len(train) => 156
len(test) => 44

### Visualizing the Training and Test Sets on the Same Plot

Before training the model, we plot both the training and test data points on the same scatter plot (with different colors) to visually confirm that:

The split appears random
Both sets cover the same range of TV and Sales values
There is no systematic bias in the split

plt.scatter(train.TV, train.Sales)
plt.scatter(test.TV, test.Sales, color='green')

#### Converting Training Data to NumPy Arrays

For the scikit-learn LinearRegression model, we need the feature and target variables as NumPy arrays (or array-like objects).

We use np.asanyarray() to convert the pandas columns from the training set into the required format.

train_x = np.asanyarray(train[['TV']])
train_y = np.asanyarray(train[['Sales']])

Fitting the Simple Linear Regression Model

We now import the LinearRegression class from scikit-learn, create a model instance, and train it using the prepared training arrays (train_x and train_y).

After running, the simple linear regression model is fully trained using only the TV advertising budget to predict Sales.

The coefficient tells us how much Sales increases (in thousand units) for every additional thousand dollars spent on TV advertising.

from sklearn.linear_model import LinearRegression

reg = LinearRegression()
reg.fit(train_x, train_y)

Visualizing the Fitted Regression Line

In this step we plot the training data points together with the regression line found by the model. This allows us to visually verify that the fitted line reasonably captures the linear relationship between TV advertising and Sales.

The line is drawn using the learned parameters:

model.coef_[0] → slope of the line
model.intercept_ → y-intercept

plt.scatter(train_x, train_y)
plt.plot(train_x, reg.coef_[0][0] * train_x + reg.intercept_[0], '-g')

Preparing Test Data and Making Predictions

We convert the test set to NumPy arrays (required format for scikit-learn) and use the trained model to predict Sales values for the test observations.

test_x = np.asanyarray(test[['TV']])
test_y = np.asanyarray(test[['Sales']])
predict_y = np.asanyarray(reg.predict(test_x))

Evaluating Model Performance with R² Score

We import the r2_score metric from scikit-learn to measure how well our Simple Linear Regression model performs on the test set.

The R² score (coefficient of determination) tells us the proportion of variance in Sales that is explained by the TV advertising budget.

R² ≈ 1.0 → perfect fit
R² ≈ 0 → model explains nothing

from sklearn.metrics import r2_score

Computing and Displaying the R² Score

We use the imported r2_score function to calculate the coefficient of determination on the test data and print the result directly.

This single line gives us the final performance metric: the higher the value (closer to 1.0),
the better our simple linear regression model using only TV advertising explains the variation in Sales.

print(f'r^2 score is : {r2_score(test_y, predict_y)}')

r^2 score is : 0.8674734235783073

follow me in github:

-https://github.com/PyRz-Tech

Build a Face Detection App with Python OOP — From Zero to Pro(part-5)

MohammadReza Mahdian — Thu, 20 Nov 2025 22:58:25 +0000

Part 5: View Rendering & Main Application (FaceApp)

Overview

This part covers:

The View class (responsible only for drawing)
The FaceApp class (main loop + webcam + detection pipeline)

🟡 View Class — Everything About Rendering

Responsibilities

Draw face ellipse
Draw eye and lip landmarks
Apply overlays
Show result using cv2.imshow

View Implementation (Your Logic — Cleaned, Structured)

class View:
    def draw_faces(self, img, faces):
        for (x, y, w, h) in faces:
            cx, cy = x + w//2, y + h//2
            cv2.ellipse(img, (cx, cy), (w//2, h//2), 0, 0, 360, (255, 255, 0), 2)
        return img

    def draw_features(self, img, features):
        if not features:
            return img

        for key in features:
            pts = features[key]
            for (x, y) in pts:
                px = int(x * img.shape[1])
                py = int(y * img.shape[0])
                cv2.circle(img, (px, py), 1, (0, 255, 0), -1)

        return img

    def show(self, img):
        cv2.imshow("FaceApp", img)

⚫ FaceApp — The Heart of the System

Responsibilities

Load YOLO model (via ConfigModel)
Initialize detectors
Open webcam (VideoCapture(0))
Run real‑time loop
Send frames to detectors
Render through View
Handle quitting (press q)
Cleanup webcam + windows

Full FaceApp Implementation

class FaceApp:
    def __init__(self):
        import cv2
        from app.config_model import ConfigModel
        from app.face_detector import FaceDetector
        from app.face_features_detector import FaceFeaturesDetector
        from app.view import View

        self.cv2 = cv2
        self.view = View()

        cfg = ConfigModel()
        self.model = cfg.load_model("yolo-face", "model/yolov9t-face-lindevs.pt")

        self.face_detector = FaceDetector(self.model)
        self.features_detector = FaceFeaturesDetector()

        self.cap = cv2.VideoCapture(0)

    def run(self):
        while True:
            ret, frame = self.cap.read()
            if not ret:
                break

            faces = self.face_detector.detect(frame)
            features = self.features_detector.extract(frame)

            frame = self.view.draw_faces(frame, faces)
            frame = self.view.draw_features(frame, features)
            self.view.show(frame)

            if self.cv2.waitKey(1) & 0xFF == ord('q'):
                break

        self.cap.release()
        self.cv2.destroyAllWindows()

Main Program

if __name__ == "__main__":
    app = FaceApp()
    app.run()

requirements.txt

-f https://download.pytorch.org/whl/cpu/torch_stable.html
torch==2.2.0+cpu
torchvision==0.17.0+cpu
torchaudio==2.2.0+cpu
opencv-python>=4.7.0
numpy>=1.26.0
ultralytics>=8.0.167
mediapipe>=0.10.21

Build a Face Detection App with Python OOP — From Zero to Pro(part-4)

MohammadReza Mahdian — Wed, 19 Nov 2025 17:02:04 +0000

Part 4: Detection Pipeline — YOLO & FaceMesh

Overview

This part explains the full logic behind:

FaceDetector (YOLOv9t‑face)
FaceFeaturesDetector (MediaPipe FaceMesh)

Both detectors extend OpenCVBase and work together.

🔴 FaceDetector — YOLOv9 Face Detection

Responsibilities

Run YOLO on input frame
Extract bounding boxes
Convert YOLO output format
Provide clean face coordinates

YOLO Prediction Flow

YOLO returns detections in the following format:

[x1, y1, x2, y2, confidence, class_id]

We convert these into:

(x, y, w, h)

Cleaned Version of Your Detector Logic

class FaceDetector(OpenCVBase):
    def __init__(self, model):
        super().__init__()
        self.model = model

    def detect(self, img):
        self.img = img
        results = self.model(img)[0]

        faces = []
        for box in results.boxes.xyxy.cpu().numpy():
            x1, y1, x2, y2 = map(int, box[:4])
            w, h = x2 - x1, y2 - y1
            faces.append((x1, y1, w, h))

        return faces

🟣 FaceFeaturesDetector — MediaPipe FaceMesh

Responsibilities

Extract all 539 landmarks
Select subsets belonging to:
- left eye
- right eye
- outer lips
- inner lips
Return a structured dictionary

Why `refine_landmarks=True`?

Because it improves accuracy on:

eyelids
iris
lips

It specifically sharpens fine-grained areas — perfect for your project.

Landmark Index Groups (Preserving Your Data)

👁 Left Eye

Indices: 33, 7, 163, 144, 145, 153, 154, 155, 133

👁 Right Eye

Indices: 263, 249, 390, 373, 374, 380, 381, 382, 362

👄 Outer Lips

Indices: 61–88

👄 Inner Lips

Indices: 0–18

(These match your custom extracted subsets.)

Example Detector Code

class FaceFeaturesDetector(OpenCVBase):
    def __init__(self):
        super().__init__()
        import mediapipe as mp
        self.mesh = mp.solutions.face_mesh.FaceMesh(
            max_num_faces=1,
            refine_landmarks=True
        )

    def extract(self, img):
        self.img = img
        results = self.mesh.process(img)

        if not results.multi_face_landmarks:
            return None

        landmarks = results.multi_face_landmarks[0].landmark

        def pts(idxs):
            return [(landmarks[i].x, landmarks[i].y) for i in idxs]

        features = {
            "left_eye": pts([33,7,163,144,145,153,154,155,133]),
            "right_eye": pts([263,249,390,373,374,380,381,382,362]),
            "outer_lip": pts(range(61,89)),
            "inner_lip": pts(range(0,19))
        }
        return features

Build a Face Detection App with Python OOP — From Zero to Pro(part-3)

MohammadReza Mahdian — Tue, 18 Nov 2025 18:53:15 +0000

Part 3: OpenCVBase — Designing a Clean Parent Class

Why Create a Base Class?

Both FaceDetector and FaceFeaturesDetector must:

Receive an image (self.img)
Read images from webcam or file
Validate input
Provide helper utilities

Instead of duplicating code, we put common logic in OpenCVBase.

Core Responsibilities of OpenCVBase

✔ Input management

Keeps self.img consistent across all detectors.

✔ Camera handling

Implements read_img() which reads from:

webcam
image path

✔ Error handling

Ensures detectors never receive invalid images.

Example Implementation

class OpenCVBase:
    def __init__(self):
        self.img = None

    def read_img(self, source=0):
        import cv2

        cap = cv2.VideoCapture(source)
        success, frame = cap.read()
        cap.release()

        if success:
            self.img = frame
            return frame
        return None

Why `0` is Default Again?

Because the default webcam is usually device index 0.

This ensures that if the user runs the app without arguments, it "just works."

Benefits of Using OpenCVBase

✔ DRY (Don’t Repeat Yourself)

Only one place to manage images.

✔ Consistent API

All detectors expect the same .img.

✔ Easy to extend

If you add preprocessing later (resize, normalization), you only add it here.

Build a Face Detection App with Python OOP — From Zero to Pro(part-2)

MohammadReza Mahdian — Mon, 17 Nov 2025 06:32:42 +0000

Part 2: ConfigModel — Centralized Model Management

Why We Need ConfigModel

YOLO models are heavy.

Reloading them inside multiple detectors would:

Waste CPU/GPU
Slow down FPS
Increase RAM consumption
Cause inconsistent model versions

So we implement ConfigModel, a class that loads models only once and stores them in a dictionary.

How ConfigModel Works

✔ `self.models = {}`

Dictionary that keeps all loaded models.

✔ `load_model(name, path)`

Loads a model only if it hasn't been loaded before.

✔ `get_model(name)`

Retrieves the loaded model for use in detectors.

Example Code (Your Structure Cleaned & Preserved)

class ConfigModel:
    def __init__(self):
        self.models = {}

    def load_model(self, model_name: str, model_path: str):
        if model_name not in self.models:
            from ultralytics import YOLO
            self.models[model_name] = YOLO(model_path)
        return self.models[model_name]

    def get_model(self, model_name: str):
        return self.models.get(model_name)

Why This Architecture Is Good

✔ Prevents duplicate loading

YOLO loads once → all detectors reuse it.

✔ Scalable

You can add as many models as you want:

YOLOv9-face
YOLOv8-pose
Segmentation models
Custom detectors

✔ Centralized

All models live in one place → debugging becomes simple.

Conclusion

ConfigModel is the foundation that keeps the entire system efficient, clean, and scalable.

Build a Face Detection App with Python OOP — From Zero to Pro(part-1)

MohammadReza Mahdian — Sun, 16 Nov 2025 03:15:19 +0000

Part 1: Introduction & Project Architecture

Overview

This project implements a complete face detection + facial feature extraction pipeline using:

YOLOv9-face for face bounding box detection
MediaPipe FaceMesh for detailed landmark extraction (eyes, lips, etc.)
A clean Object‑Oriented (OOP) architecture to keep everything modular, extensible, and production‑ready.

The tutorial explains everything in depth — what each class does, why it exists, and how all pieces work together.

Why OOP for a CV project?

✔ Single Responsibility

Each class handles one job:

Detecting faces
Extracting features
Rendering
Managing models
Running the main loop

✔ DRY Principles

Common functionality (image handling, webcam reading, etc.) lives in a single parent class: OpenCVBase.

✔ Scalability

Add a new model? New feature extractor? New rendering theme?

Just create a new class without touching existing ones.

✔ Performance

ConfigModel loads models once, preventing heavy repetitive initialization.

Project Structure

project/
│
├── app/
│   ├── config_model.py
│   ├── opencv_base.py
│   ├── face_detector.py
│   ├── face_features_detector.py
│   ├── view.py
│   ├── face_app.py
│
├── model/
│   └── yolov9t-face-lindevs.pt
│
└── main.py

Component Responsibilities

🔵 ConfigModel

Loads and caches models (YOLO, etc). Prevents loading multiple times.

🟢 OpenCVBase

Parent class that provides:

self.img
read_img()
camera reading logic All detectors inherit from it.

🔴 FaceDetector

Uses YOLO to detect faces and returns bounding boxes.

🟣 FaceFeaturesDetector

Uses MediaPipe FaceMesh to extract:

Left eye landmarks
Right eye landmarks
Outer lips
Inner lips

🟡 View

Only responsible for drawing:

Ellipses around faces
Feature overlays
Weighted blending
Rendering with cv2.imshow

⚫ FaceApp

Main "application controller":

Opens webcam (VideoCapture(0))
Runs detection pipeline
Sends results to View
Handles exit logic
Cleans up resources

`VideoCapture(0)` — Why Zero?

0 represents the default webcam.

If you have multiple cameras:

0 → laptop camera
1 → USB webcam
2 → virtual camera

This project uses webcam input in both OpenCVBase and FaceApp.

BasicOOPConcept

MohammadReza Mahdian — Sat, 15 Nov 2025 03:42:08 +0000

Object-Oriented Thinking

MohammadRezaMahdian – November 2025
November 15, 2025

What is OOP?

Imagine you're building with LEGO. Every brick is an object — it has a shape, a color, and it does something.
OOP is just that: organizing your code like a LEGO set.

Why bother?

Your program starts small. Then it grows. And suddenly? Chaos.
OOP keeps things clean, fixable, and easy to grow. Fewer headaches down the road.

The 4 Core Ideas

Class — the blueprint
Polymorphism — same command, different behavior
Inheritance — borrow from a parent
Composition — build from smaller pieces

Class = Blueprint

A class says: “Here’s what something is, and what it can do.”

class Dog:
    def __init__(self, name, breed):
        self.name = name      # data
        self.breed = breed

    def bark(self):           # action
        print("Woof!")

Object = Real Thing

Now make a real dog:

my_dog = Dog("Rex", "German Shepherd")
my_dog.bark()
# → Woof!

Has-A = Composition

Ask: “What does this thing have?” → That’s composition.

A Car has an Engine. Take the engine out? No car.

class Engine:
    def start(self):
        print("Engine running")

class Car:
    def __init__(self):
        self.engine = Engine()  # Car HAS an Engine

    def drive(self):
        self.engine.start()

Strong bond — parts live and die with the whole.

Is-A = Inheritance

Ask: “What is this thing?” → That’s inheritance.

A PoliceCar is a Car.

class PoliceCar(Car):
    def siren(self):
        print("Wee-woo!")

Now it can drive() and siren().

Hide the Mess (Encapsulation)

Don’t let anyone poke the insides.

class BankAccount:
    def __init__(self):
        self.__balance = 500  # hidden

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance

Only through deposit() and get_balance().

Getters & Setters

def get_speed(self):
    return self.speed

def set_speed(self, value):
    if value >= 0:
        self.speed = value

Class vs Object

Class	Object
Blueprint	Real instance
One definition	Many copies
In code	In memory

Composition vs Aggregation

Composition: Strong → Engine dies with Car
Aggregation: Weak → Players can leave Team

class Player:
    pass

class Team:
    def __init__(self):
        self.players = []

    def add_player(self, p):
        self.players.append(p)

How to Design

What does it have? → attributes
What does it do? → methods

Cat → name, age → meow(), sleep()

Objects Talk

car.drive()
account.deposit(100)

Keep It Clean

Hide complexity. Reuse. Build step by step.

Bottom Line

OOP isn’t magic. It’s thinking about code like real life.
Makes big programs manageable.

MohammadRezaMahdian – Nov 2025

Forem: MohammadReza Mahdian

Decision Tree vs KNN: The No-BS Truth Every Developer Needs to Know (3-Minute Read)

Decision Tree vs KNN – A no-BS comparison

Summary – when is which one better:

Why everyone fails at the California Housing dataset the same way(6 brutal reasons)

Why You’ll Never Build a Strong Model with the 9 Raw Features of the California Housing Dataset (6 Key Insights)

Occam’s Razor destroyed my polynomial model in 5 minutes

More complex model ≠ better model

(That’s literally Occam’s Razor in action)

1. Import Libraries & Generate Synthetic Linear Data with Noise

Generate perfectly linear data with noise

Plot: Data + True Relationship

2. Convert to DataFrame & Train/Test Split

3. Simple Linear Regression

4. Polynomial Regression (Degree 2)

5. Final Comparison & Overfitting Detection

Conclusion

The Regression Coefficient Was Positive… Until I Added One Variable and It Flipped Negative

Why a Regression Coefficient Can Turn Negative When the Bivariate Relationship Is Clearly Positive

Why Can a Coefficient Become Negative in Multiple Linear Regression

When Its Bivariate Relationship Is Clearly Positive?

Load the dataset

Select features and target

Train/test split

Fit multiple linear regression

Model performance

The diagnostic plot that reveals everything

Why the sign reversal happens

Key takeaways

How I Built a 140 FPS Real-Time Face Landmark App with Just YOLOv9 + MediaPipe (5-Part Series)

Series Contents

Tech Stack

Why this series stands out

Simple Linear Regression in Python – From Zero to 87% Accuracy in 10 Minutes

Loading the Required Packages

Dataset Introduction – The Classic Advertising Dataset

Level 2: Loading and Initial Inspection of the Dataset

Quick Summary of What We’ve Seen So Far

Visual Inspection of Individual Feature–Sales Relationships

Visual Inspection Using Matplotlib’s scatter() Method

Visual Analysis Summary and Feature Selection for Simple Linear Regression

Selected Feature

Creating a Clean Subset for Focused Analysis

Train-Test Split (Manual Random Split)

Fitting the Simple Linear Regression Model

Visualizing the Fitted Regression Line

Preparing Test Data and Making Predictions

Evaluating Model Performance with R² Score

Computing and Displaying the R² Score

follow me in github:

Build a Face Detection App with Python OOP — From Zero to Pro(part-5)

Part 5: View Rendering & Main Application (FaceApp)

Overview

🟡 View Class — Everything About Rendering

Responsibilities

View Implementation (Your Logic — Cleaned, Structured)

⚫ FaceApp — The Heart of the System

Responsibilities

Full FaceApp Implementation

Main Program

requirements.txt

Build a Face Detection App with Python OOP — From Zero to Pro(part-4)

Part 4: Detection Pipeline — YOLO & FaceMesh

Overview

🔴 FaceDetector — YOLOv9 Face Detection

Responsibilities

YOLO Prediction Flow

Cleaned Version of Your Detector Logic

🟣 FaceFeaturesDetector — MediaPipe FaceMesh

Responsibilities

Why refine_landmarks=True?

Landmark Index Groups (Preserving Your Data)

👁 Left Eye

👁 Right Eye

👄 Outer Lips

👄 Inner Lips

Example Detector Code

Build a Face Detection App with Python OOP — From Zero to Pro(part-3)

Part 3: OpenCVBase — Designing a Clean Parent Class

Why Create a Base Class?

Why `refine_landmarks=True`?

Why `0` is Default Again?

✔ `self.models = {}`

✔ `load_model(name, path)`

✔ `get_model(name)`

`VideoCapture(0)` — Why Zero?