Listen to this Post
Introduction:
The gap between “using AI” and “understanding AI” is wider than most practitioners admit. While countless tutorials teach you how to call an API or fine-tune a pre-trained model, few address the foundational question: what actually happens under the hood? Jappan Rana, an AI Engineer working with enterprise clients like Kotak Mahindra, Paytm, and PhonePe, recently launched a public learning journey that cuts through the noise. His approach? Start from scratch, assume minimal math, build every algorithm by hand, and document the entire process in a structured GitHub repository. This article extracts the technical blueprint from his Day 0 setup and expands it into a comprehensive guide for anyone serious about mastering machine learning fundamentals.
Learning Objectives:
- Design a practical, project-based ML learning roadmap using AI-assisted planning tools
- Set up a professional development environment with version control, virtual environments, and dependency management
- Implement core supervised and unsupervised learning algorithms from scratch without relying on high-level abstractions
- Understand the mathematical and statistical principles underlying modern AI systems
- Build a portfolio of verifiable ML projects that demonstrate deep conceptual understanding
You Should Know:
- Project Scaffolding: The Foundation of Every ML Repository
Jappan Rana’s first action was asking ChatGPT to design a folder structure that would scale from beginner algorithms to advanced topics. The resulting repository, available at https://github.com/jappanrana/Ai-ML.git, follows a logical progression through the ML landscape.
The repository is organized into distinct phases:
- Phase 1 (Supervised Learning – Fundamentals): Linear Regression, Logistic Regression, K-1earest Neighbors, Decision Trees, Random Forest, Naive Bayes, Support Vector Machines
- Phase 2 (Supervised Learning – Ensemble Methods): Bagging, AdaBoost, Gradient Boosting, XGBoost, LightGBM, CatBoost
- Phase 3 (Unsupervised Learning): K-Means Clustering, Hierarchical Clustering, DBSCAN, Principal Component Analysis
- Phase 4 (Deep Learning): Neural Networks, Convolutional Neural Networks, Recurrent Neural Networks, LSTMs, Transformers
- Specialized Tracks: Natural Language Processing, Computer Vision, Reinforcement Learning, and Portfolio Projects
Step-by-step guide to replicating this structure:
1. Initialize the repository:
mkdir Ai-ML && cd Ai-ML git init
2. Create the folder hierarchy:
mkdir -p supervised-learning/{linear-regression,logistic-regression,knn,decision-tree,random-forest,naive-bayes,svm}
mkdir -p supervised-learning/{bagging,adaboost,gradient-boosting,xgboost,lightgbm,catboost}
mkdir -p unsupervised-learning/{kmeans,hierarchical,dbscan,pca}
mkdir -p deep-learning/{nn,cnn,rnn,lstm,transformers}
mkdir -p nlp computer-vision reinforcement-learning projects utils
3. Set up the Python environment (cross-platform):
Linux/macOS:
python3 -m venv .venv source .venv/bin/activate
Windows (Command Prompt):
python -m venv .venv .venv\Scripts\activate
Windows (PowerShell):
python -m venv .venv .venv\Scripts\Activate.ps1
4. Create a `requirements.txt` file with essential libraries:
numpy==1.26.0 pandas==2.1.0 scikit-learn==1.3.0 matplotlib==3.7.0 seaborn==0.12.0 jupyter==1.0.0 tensorflow==2.13.0 torch==2.0.0 transformers==4.31.0 xgboost==1.7.0 lightgbm==4.0.0 catboost==1.2.0
5. Install dependencies:
pip install -r requirements.txt
- Create a `.gitignore` file to exclude virtual environments, cache files, and large datasets:
.venv/ <strong>pycache</strong>/ .pyc .DS_Store .ipynb_checkpoints/ data/ .pkl .h5 .pb
-
Environment Configuration: VS Code + GitHub Copilot for Accelerated Learning
Rana’s setup leveraged VS Code with GitHub Copilot to generate the project scaffold while deliberately leaving the algorithm implementations blank. This approach enforces active learning—you write every line of algorithmic code yourself, building muscle memory and conceptual understanding simultaneously.
Step-by-step guide to configuring your development environment:
- Install VS Code from https://code.visualstudio.com/
2. Install essential extensions:
- Python (Microsoft)
- Jupyter
- GitHub Copilot (if available)
- Pylance
- GitLens
3. Configure the Python interpreter:
- Open Command Palette (
Ctrl+Shift+1/Cmd+Shift+1) - Select “Python: Select Interpreter”
- Choose the interpreter from your `.venv` folder
4. Set up workspace settings (`.vscode/settings.json`):
{
"python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
"python.terminal.activateEnvironment": true,
"python.linting.enabled": true,
"python.linting.pylintEnabled": true,
"editor.formatOnSave": true,
"jupyter.notebookFileRoot": "${workspaceFolder}"
}
Security consideration: When working with ML pipelines that may process sensitive data, always store credentials and API keys in environment variables rather than hardcoding them in notebooks or scripts.
- The Math Barrier: Why You Don’t Need to Be a Mathematician
One of the most powerful statements in Rana’s post is: “My math isn’t good enough. Mine isn’t either. I haven’t seriously studied statistics, linear algebra, or calculus in the last 2–3 years.” This directly addresses the primary barrier that prevents aspiring ML engineers from starting.
The reality is that modern ML practice requires conceptual understanding rather than computational proficiency. You need to know:
- What a gradient is (direction of steepest ascent) — not how to compute partial derivatives by hand
- What a matrix multiplication represents (linear transformations) — not how to perform it manually
- What statistical significance means — not how to derive p-values from first principles
Practical approach to learning the math:
- Linear Algebra: Focus on vectors, matrices, dot products, and eigenvalues. Use NumPy to experiment:
import numpy as np A = np.array([[1, 2], [3, 4]]) B = np.array([[5, 6], [7, 8]]) print("Matrix multiplication:\n", np.dot(A, B)) print("Eigenvalues:", np.linalg.eigvals(A)) -
Calculus: Understand derivatives as rates of change and gradients as vectors of partial derivatives:
Numerical gradient approximation def numerical_gradient(f, x, h=1e-5): grad = np.zeros_like(x) for i in range(x.size): x_plus = x.copy(); x_plus[bash] += h x_minus = x.copy(); x_minus[bash] -= h grad[bash] = (f(x_plus) - f(x_minus)) / (2h) return grad
-
Statistics: Master mean, variance, standard deviation, correlation, and the concepts of overfitting/underfitting:
from scipy import stats Calculate correlation and p-value correlation, p_value = stats.pearsonr(X, y)
-
From Theory to Implementation: Building Algorithms from Scratch
The core philosophy of this learning journey is implementation-first. Each algorithm folder should contain:
- A `README.md` with theoretical explanation and use cases
- A Jupyter notebook (
implementation.ipynb) with step-by-step code - A Python script (
model.py) for production-ready implementation - A `test.py` file for validation against scikit-learn implementations
Example: Implementing Linear Regression from Scratch
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
class LinearRegressionScratch:
def <strong>init</strong>(self, learning_rate=0.01, n_iterations=1000):
self.learning_rate = learning_rate
self.n_iterations = n_iterations
self.weights = None
self.bias = None
def fit(self, X, y):
n_samples, n_features = X.shape
self.weights = np.zeros(n_features)
self.bias = 0
for _ in range(self.n_iterations):
Forward pass: prediction
y_predicted = np.dot(X, self.weights) + self.bias
Compute gradients
dw = (1/n_samples) np.dot(X.T, (y_predicted - y))
db = (1/n_samples) np.sum(y_predicted - y)
Update parameters
self.weights -= self.learning_rate dw
self.bias -= self.learning_rate db
def predict(self, X):
return np.dot(X, self.weights) + self.bias
Generate synthetic data
X, y = make_regression(n_samples=200, n_features=1, noise=20, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
Train and evaluate
model = LinearRegressionScratch(learning_rate=0.01, n_iterations=1500)
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(f"R² Score: {r2_score(y_test, predictions):.4f}")
print(f"MSE: {mean_squared_error(y_test, predictions):.4f}")
Verification step: Always compare your implementation against scikit-learn’s optimized version to ensure correctness:
from sklearn.linear_model import LinearRegression
sk_model = LinearRegression()
sk_model.fit(X_train, y_train)
sk_predictions = sk_model.predict(X_test)
print(f"Scikit-learn R²: {r2_score(y_test, sk_predictions):.4f}")
- Dataset Strategy: Where to Find Quality Data for Each Algorithm
Rana’s prompt specifically asked ChatGPT for dataset recommendations. For a structured learning path, here are verified dataset sources for each algorithm category:
Regression datasets:
- Boston Housing (built into scikit-learn) – for Linear Regression
- California Housing (
sklearn.datasets.fetch_california_housing) – for ensemble methods - Diabetes dataset (
sklearn.datasets.load_diabetes) – for feature analysis
Classification datasets:
- Iris (
sklearn.datasets.load_iris) – for Logistic Regression, KNN, Decision Trees - Wine (
sklearn.datasets.load_wine) – for Random Forest, SVM - Breast Cancer (
sklearn.datasets.load_breast_cancer) – for Naive Bayes - MNIST (via
tensorflow.keras.datasets.mnist) – for deep learning
Unsupervised learning datasets:
- Blobs (
sklearn.datasets.make_blobs) – for K-Means - Circles (
sklearn.datasets.make_circles) – for DBSCAN - Ollivier’s dataset – for hierarchical clustering demonstrations
NLP datasets:
- IMDB Reviews (
tensorflow.keras.datasets.imdb) – for sentiment analysis - 20 Newsgroups (
sklearn.datasets.fetch_20newsgroups) – for text classification
Computer Vision datasets:
- CIFAR-10 (
tensorflow.keras.datasets.cifar10) – for CNN training - Fashion-MNIST – for image classification practice
Pro tip: Always document the dataset source, preprocessing steps, and any licensing considerations in each algorithm folder’s README.
6. The “Understanding AI” vs. “Using AI” Distinction
Rana makes a critical clarification: “This is not a Generative AI project. We’re not building chatbots, AI agents, or applications powered by LLM APIs. This journey is about understanding the fundamentals of Machine Learning.”
This distinction is vital for several reasons:
- Debugging capability: When a production RAG pipeline fails, understanding gradient descent helps you diagnose whether the issue is data quality, model architecture, or optimization hyperparameters.
-
Model selection: Knowing when to use Random Forest vs. Gradient Boosting vs. a Transformer requires understanding their theoretical underpinnings, not just API familiarity.
-
Customization: Off-the-shelf models rarely fit enterprise use cases perfectly. The ability to modify loss functions, add regularization, or design custom architectures comes from foundational knowledge.
-
Security implications: ML models can be vulnerable to adversarial attacks, data poisoning, and inference attacks. Understanding the mathematics of how models learn is essential for implementing robust security measures.
Security hardening for ML pipelines:
- Input validation: Always validate and sanitize input data before feeding it to models
- Model encryption: Encrypt model weights at rest using AES-256
- API security: Implement rate limiting, authentication, and logging for model endpoints
- Data privacy: Use differential privacy techniques when training on sensitive data
- Adversarial robustness: Test models against FGSM (Fast Gradient Sign Method) attacks:
def fgsm_attack(model, image, epsilon, gradient): Generate adversarial example perturbed_image = image + epsilon np.sign(gradient) return np.clip(perturbed_image, 0, 1)
- Version Control and Documentation: Building a Public Portfolio
Rana emphasizes that his GitHub contains “only the project scaffold—no ML code yet. Every implementation from this point onward will be written step by step as part of this series.” This transparency and commitment to public learning is a best practice for any aspiring ML engineer.
Recommended commit strategy:
- Day 0 commit: Repository initialization, folder structure, environment setup
- Per-algorithm commits: One commit per completed algorithm with:
– Implementation code
– Jupyter notebook with explanations
– Test suite
– README updates
3. Documentation commits: Regularly update the main README with progress, learnings, and challenges
Git commands for structured commits:
After completing an algorithm git add supervised-learning/linear-regression/ git commit -m "feat: implement Linear Regression from scratch with evaluation metrics" git push origin main Tagging milestones git tag -a v1.0-linear-regression -m "Complete Linear Regression implementation" git push origin --tags
README template for each algorithm folder:
[Algorithm Name] Theory - Mathematical formulation - When to use (pros/cons) - Key hyperparameters Implementation - Custom implementation from scratch - Scikit-learn comparison Results - Performance metrics - Visualizations References - Research papers - Tutorials - Dataset sources
What Undercode Say:
- Start before you’re ready. The math anxiety is universal—even experienced practitioners forget details they don’t use daily. The key is to start implementing and learn the math contextually as you encounter it.
- Build in public. Sharing your journey on platforms like LinkedIn and GitHub creates accountability, attracts feedback, and builds a portfolio that speaks louder than any certificate.
- Understand before you abstract. Using scikit-learn’s `fit()` and `predict()` is easy. Writing those methods yourself is where real learning happens. The difference between “using AI” and “understanding AI” is the difference between being a consumer and being a creator.
Analysis: Rana’s approach represents a refreshing counter-trend to the “learn AI in 30 days” hype. By explicitly stating that he’s not building generative AI applications, he’s signaling that foundational knowledge still matters—perhaps more than ever in an era where LLMs abstract away complexity. For enterprise AI engineers working with financial institutions like Kotak Mahindra and Paytm, this depth of understanding is non-1egotiable. Models that handle sensitive financial data require explainability, robustness, and security that can only come from first-principles understanding. The GitHub repository, with its structured phases from linear regression to transformers, provides a reusable template that could serve as the backbone for corporate ML training programs. The emphasis on implementation from scratch, rather than just API usage, aligns with best practices in software engineering where understanding dependencies and internals is valued over mere functionality.
Prediction:
- +1 The trend toward “prompt engineering” and API-centric AI development will create a skills gap where practitioners who understand fundamentals become increasingly valuable for enterprise-critical applications.
- +1 Open-source learning repositories like this one will become the new standard for ML education, replacing traditional degree programs for practical, job-ready skills.
- -1 The oversaturation of “AI experts” who only know how to call APIs will lead to increased security vulnerabilities and model failures in production, driving demand for deeper expertise.
- +1 Companies will begin requiring candidates to implement algorithms from scratch during technical interviews to filter out superficial knowledge.
- -1 The pressure to ship AI products quickly may discourage organizations from investing in foundational training, creating long-term technical debt.
- +1 The “learn in public” movement will continue to grow, with GitHub portfolios becoming more valuable than credentials for ML engineering roles.
▶️ Related Video (74% Match):
🎯Let’s Practice For Free:
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
IT/Security Reporter URL:
Reported By: Jappan Machinelearning – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
