added badges

Author: prgyn8

README.md

@@ -1,95 +1,151 @@
+<div align="center">
 
-#### **A comprehensive implementation of various Matrix Decomposition Techniques from the lens of Linear Algebra to produce efficient computing of SVD, PCA, Feature Selection & Data Analysis in Python.**
-______________________________________________________________________
+# Matrix Decompositions Implemenations
 
-To gain a deeper understanding of how Orthogonalization & Matrices Decomposition works in real-life applications, & how they save bunch of time through an approach of vectorization, you'll find such techniques used in;
+**A hands-on, math-first implementation of Matrix Decomposition techniques —**  
+**from Gram-Schmidt Orthogonalization to SVD, PCA & beyond.**
 
-- **📡 Signal Processing**
-- **🤖 Control Systems and Robotics**
-- **🖼️ Image Processing**
-- **➗ Solving Linear Systems i.e. *AX = B***
+<br/>
 
-With certain mathematical intuitions (*having visual introspections*),this project simplifies most of the abstract concepts and becomes easier to grasp and connect with practical applications.
+[![Open in molab](https://molab.marimo.io/molab-shield.svg)](https://molab.marimo.io/notebooks/nb_TAVLehyiE58b5RDzjxFxSW)
+[![HF Spaces](https://img.shields.io/badge/HuggingFace-Spaces-FFD21F?style=flat-square&logo=huggingface&logoColor=yellow)](https://huggingface.co/spaces/your-hf-spaces-link-here)
+[![Python](https://img.shields.io/badge/Python-3.12%2B-3776AB?style=flat-square&logo=python&logoColor=white)](https://www.python.org/)
+[![NumPy](https://img.shields.io/badge/NumPy-2.4%2B-013243?style=flat-square&logo=numpy)](https://numpy.org/)
+[![License](https://img.shields.io/badge/License-MIT-22C55E?style=flat-square)](LICENSE)
+[![Live Demo](https://img.shields.io/badge/Live%20Demo-GitHub%20Pages-6366F1?style=flat-square&logo=github)](https://pragyntiwari.github.io/Matrix-Decompositions-Implementation-for-SVD-PCA)
 
-![a snippet of notebook](.assets/matrix_snippet.gif)
+<img src=".assets/01.gif" alt="Matrix Decompositions Demo" width="620"/>
 
-> You'll yet to see more implementations—such as **Householder Reflection**, **Bidiagonalization**, **LU Decomposition**, on this repo, and others—*these will be added soon*.
+</div>
 
-## What's Inside
+---
 
-*By latest ✨,*
+## Overview
 
-The **Gram-Schmidt Orthogonalization** is one of the fundamental process in Linear Algebra to achieve *Orthonormal Vectors* for a given vector space. The Orthonormal Basis are produced by iteratively removing vector projections — also known as the *Vector Projection Elimination method*.
+A curated set of [marimo](https://marimo.io) notebooks based on **Matrix Decomposition** functions, written in Python — each pairing a rigorous mathematical derivation with annotated Python and an interactive visualization, in a single reactive environment.
 
-**Terms like Orthogonality, QR Decomposition are being discussed in the — [🗨️Discussion section](https://github.com/PragyanTiwari/Matrix-Decompositions-Implementation-for-SVD-PCA/discussions).**
+The series is a progressive build, starting from orthogonalization fundamentals and working toward full matrix factorizations and applications:
 
-Here's a snippet;
+`Gram-Schmidt` → `QR` → `LU` → `Householder` → `SVD` → `PCA`
 
-```bash
-def gs_Orthogonalization(X:np.ndarray)->np.ndarray:
+> **Main Motive —** Matrix decompositions reduce computationally expensive operations — inversion, least squares, eigensolving — into sequences of simpler, numerically stable factors. This project builds that machinery from the ground up, reducing the computational overhead at each step.
 
-    Q = np.copy(X).astype("float64")
-    n_vecs = Q.shape[1]
+>> Applications such as **noise reduction, signal processing, image compression** and more will be covered as the series progresses.
 
-    # defining a function to compute the L2-norm
-    length = lambda x: np.linalg.norm(x)
+---
 
-    # iteration with each vector in the matrix X
-    for nth_vec in range(n_vecs):
+## Marimo Apps
 
-        # iteratively removing each preceding projection from nth vector
-        for k_proj in range(nth_vec):
+| Notebook | Open in molab | Open in HF Spaces |
+|---|:---:|:---:|
+| **Gram-Schmidt Orthogonalization** | [![Open in molab](https://molab.marimo.io/molab-shield.svg)](https://molab.marimo.io/notebooks/nb_TAVLehyiE58b5RDzjxFxSW/app) | [![HF Spaces](https://img.shields.io/badge/HuggingFace-Spaces-FFD21F?style=flat-square&logo=huggingface&logoColor=black)](https://huggingface.co/spaces/PragyanTiwari/Gram-Schmidt-Orthonormal-Basis) |
+| **QR Decomposition** | 🔜 | 🔜 |
+| **Householder Reflection & Bidiagonalization** | 🔜 | 🔜 |
 
-            # the dot product would be the scaler coefficient 
-            scaler = Q[:,nth_vec] @ Q[:,k_proj]
-            projection = scaler * Q[:,k_proj]
-            Q[:,nth_vec] -= projection                 # removing the Kth projection
+---
 
-        norm = length(Q[:,nth_vec])
+## Quickstart
 
-        # handling the case if the loop encounters linearly dependent vectors. 
-        # Since, they come already under the span of vector space, hence their value will be 0.
-        if np.isclose(norm,0, rtol=1e-15, atol=1e-14, equal_nan=False):
-            Q[:,nth_vec] = 0
-        else:
-            # making orthogonal vectors -> orthonormal
-            Q[:,nth_vec] = Q[:,nth_vec] / norm
+Requires Python `>= 3.12` and [`uv`](https://docs.astral.sh/uv/).
 
-    return Q
+**1. Clone and install dependencies**
+
+```bash
+git clone https://github.com/PragyanTiwari/Matrix-Decompositions-Implementation-for-SVD-PCA.git
+cd Matrix-Decompositions-Implementation-for-SVD-PCA
+uv sync
 ```
 
-To run the notebook in a sandbox environment;
+**2. Run a marimo app**
 
 ```bash
+uvx marimo run apps/gs_process.py
+```
+
+**3. Optional — run any notebook in a sandboxed environment**
+
+```bash
+# No global installs — dependencies are inlined in the notebook
 uvx marimo run --sandbox notebooks/Gram_Schmidt_QR_Decomposition.py
+
+# Or open for editing
+uvx marimo edit --sandbox notebooks/Gram_Schmidt_QR_Decomposition.py
 ```
 
-## 🧪 Testing
+---
 
-The updates made on this project, can be tested for deployment, (and for personal experimentation) by the following;
+## Implementation Notes
 
-- Fork the repository.
+<details>
+<summary><strong>Gram-Schmidt Orthogonalization</strong></summary>
 
-- Run uv sync to install dependencies (*uv lockfile will help*)
+<br/>
 
-```bash
-uv sync
-```
+```python
+import numpy as np
 
-- To test the export process, we'll run `.github/scripts/build.py` from the root directory through a symlink.
+def gram_schmidt(X: np.ndarray) -> np.ndarray:
+    """
+    Transforms linearly independent column vectors into an orthonormal matrix Q.
+    Q.T @ Q = I  (verified below)
+    """
+    Q = np.copy(X).astype("float64")
+    for i in range(Q.shape[1]):
+        for j in range(i):
+            Q[:, i] -= (Q[:, i] @ Q[:, j]) * Q[:, j]   # remove j-th projection
+        norm = np.linalg.norm(Q[:, i])
+        Q[:, i] = 0 if np.isclose(norm, 0, atol=1e-14) else Q[:, i] / norm
+    return Q
+```
 
-```bash
-uv run .github/scripts/build.py
+```python
+# Verification: Q.T @ Q ≈ I
+A = np.array([[1, 0, 0], [2, 0, 3], [4, 5, 6]]).T
+assert np.allclose(gram_schmidt(A).T @ gram_schmidt(A), np.eye(3))  # ✓
 ```
 
-This will export all notebooks in a folder called `_site/` in the root directory
+> 💬 Questions on implementation or numerical stability? Start a thread in [Discussions](https://github.com/PragyanTiwari/Matrix-Decompositions-Implementation-for-SVD-PCA/discussions).
+
+</details>
+
+*Implementation notes for each technique will be added as notebooks are released.*
+
+---
+
+## Contributing
+
+Contributions are welcome — whether it's a bug report, a new decomposition technique, or a clearer explanation of the math.
+
+1. **Fork** the repository
+2. **Sync** dependencies: `uv sync`
+3. **Create a branch** for your changes
+4. **Open a Pull Request** — maintainers will review it
+
+For questions, suggestions, or discussion of the mathematics:
+
+- 💬 [Discussion Board](https://github.com/PragyanTiwari/Matrix-Decompositions-Implementation-for-SVD-PCA/discussions)
+- 🐛 [Open an Issue](https://github.com/PragyanTiwari/Matrix-Decompositions-Implementation-for-SVD-PCA/issues)
+
+---
+
+## Resources & Acknowledgements
+
+- [**Wikipedia** — Gram-Schmidt Process](https://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process) — foundational definitions and mathematical references
+- [**DataCamp** — Orthogonal Matrices](https://www.datacamp.com/tutorial/orthogonal-matrix) — accessible article on orthogonality
+- [**MIT OpenCourseWare** — Lecture 17](https://ocw.mit.edu/courses/18-06-linear-algebra-spring-2010/resources/lecture-17-orthogonal-matrices-and-gram-schmidt/) — in-depth treatment by *Prof. Gilbert Strang*
+- [**Steve Brunton**](https://www.youtube.com/@Eigensteve) — original spark for this project; exceptional intuition on engineering applications of linear algebra
+- [**Graphical Linear Algebra**](https://graphicallinearalgebra.net/2017/08/09/orthogonality-and-projections/) — visual treatment of orthogonality and projections
+
+---
 
-## 🌱 Contribution Guide
+<div align="center">
 
-- If you find a bug or have a feature request, please open an [Issue](https://github.com/PragyanTiwari/Matrix-Decompositions-Implementation-for-SVD-PCA/issues).
+**Try it without any setup →** &nbsp; [![Open in molab](https://molab.marimo.io/molab-shield.svg)](https://molab.marimo.io/notebooks/nb_TAVLehyiE58b5RDzjxFxSW/app)
 
-- PR will be reviewed by the maintainers.
+<br/>
 
-- Questions & Suggestions can be queried on the [Discussion section](https://github.com/PragyanTiwari/Matrix-Decompositions-Implementation-for-SVD-PCA/discussions).
+[⭐ Star this repo](https://github.com/prgyn8/Matrix-Decomposition-Implementations/stargazers) &nbsp;·&nbsp;
+[💬 Join the Discussion](https://github.com/prgyn8/Matrix-Decomposition-Implementations/discussions) &nbsp;·&nbsp;
+[Made by Pragyan →](https://your-personal-link-here)
 
-______________________________________________________________________
+</div>