sylearn 0.1.0__tar.gz

sylearn-0.1.0/.gitignore

@@ -0,0 +1,26 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Virtual Environment
+.venv/
+venv/
+ENV/
+env/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE & Notebook checkpoints
+.ipynb_checkpoints
+.vscode/
+.idea/
+
+# Python packaging builds
+dist/
+build/
+*.egg-info/

sylearn-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shashank
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sylearn-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.5
+Name: sylearn
+Version: 0.1.0
+Summary: Linear regression, decision tree and random forest regressors written from scratch in NumPy.
+Author: Shashank
+License-Expression: MIT
+License-File: LICENSE
+Keywords: decision tree,from scratch,linear regression,machine learning,numpy,random forest
+Classifier: Intended Audience :: Education
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.22
+Description-Content-Type: text/markdown
+
+# sylearn
+
+Regression models written from scratch with only NumPy. No scikit-learn inside.
+
+- `syLinearRegression`: ordinary least squares, solved with the pseudo-inverse
+- `syDecisionTreeRegressor`: a regression tree that picks splits by mean squared error
+- `syRandomForestRegressor`: bagging (bootstrap samples) over `syDecisionTreeRegressor`
+
+They were built to learn how these models work inside. On an air-quality (AQI) dataset they reach the same R² as scikit-learn's models with the same settings.
+
+## Install
+
+```bash
+pip install sylearn
+```
+
+## Use
+
+```python
+import numpy as np
+from sylearn import syLinearRegression, syDecisionTreeRegressor, syRandomForestRegressor
+
+X = np.random.rand(200, 3)
+y = 4 * X[:, 0] - 2 * X[:, 1] + np.random.normal(0, 0.1, 200)
+
+lr = syLinearRegression()
+weights, intercept = lr.fit(X, y)   # fit returns the learned weights and intercept
+print(lr.predict(X[:5]))
+
+tree = syDecisionTreeRegressor(max_depth=5, min_samples_split=2).fit(X, y)
+print(tree.predict(X[:5]))
+
+np.random.seed(42)                  # the forest uses np.random, so seed it for repeatable results
+forest = syRandomForestRegressor(n_trees=10, max_depth=5).fit(X, y)
+print(forest.predict(X[:5]))
+```
+
+`X` can be a NumPy array, a list of lists or a pandas DataFrame. `y` is a 1-D array.
+
+## Good to know
+
+- The decision tree tries every possible split, so training gets slow on large datasets (tens of thousands of rows).
+- The models do not handle missing values. Fill or drop NaN values first.
+
+## License
+
+MIT

sylearn-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+# Packaging for the sylearn library (pip install sylearn).
+# Only the sylearn/ folder is published. The AQI app (app.py, dashboard/, models/, Data/) is not.
+
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sylearn"
+version = "0.1.0"
+description = "Linear regression, decision tree and random forest regressors written from scratch in NumPy."
+readme = "sylearn/README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+authors = [{ name = "Shashank" }]
+dependencies = ["numpy>=1.22"]
+keywords = ["machine learning", "from scratch", "linear regression", "decision tree", "random forest", "numpy"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Education",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["sylearn"]
+
+[tool.hatch.build.targets.sdist]
+include = ["sylearn/*.py", "sylearn/README.md", "LICENSE", "pyproject.toml"]

sylearn-0.1.0/sylearn/README.md

@@ -0,0 +1,47 @@
+# sylearn
+
+Regression models written from scratch with only NumPy. No scikit-learn inside.
+
+- `syLinearRegression`: ordinary least squares, solved with the pseudo-inverse
+- `syDecisionTreeRegressor`: a regression tree that picks splits by mean squared error
+- `syRandomForestRegressor`: bagging (bootstrap samples) over `syDecisionTreeRegressor`
+
+They were built to learn how these models work inside. On an air-quality (AQI) dataset they reach the same R² as scikit-learn's models with the same settings.
+
+## Install
+
+```bash
+pip install sylearn
+```
+
+## Use
+
+```python
+import numpy as np
+from sylearn import syLinearRegression, syDecisionTreeRegressor, syRandomForestRegressor
+
+X = np.random.rand(200, 3)
+y = 4 * X[:, 0] - 2 * X[:, 1] + np.random.normal(0, 0.1, 200)
+
+lr = syLinearRegression()
+weights, intercept = lr.fit(X, y)   # fit returns the learned weights and intercept
+print(lr.predict(X[:5]))
+
+tree = syDecisionTreeRegressor(max_depth=5, min_samples_split=2).fit(X, y)
+print(tree.predict(X[:5]))
+
+np.random.seed(42)                  # the forest uses np.random, so seed it for repeatable results
+forest = syRandomForestRegressor(n_trees=10, max_depth=5).fit(X, y)
+print(forest.predict(X[:5]))
+```
+
+`X` can be a NumPy array, a list of lists or a pandas DataFrame. `y` is a 1-D array.
+
+## Good to know
+
+- The decision tree tries every possible split, so training gets slow on large datasets (tens of thousands of rows).
+- The models do not handle missing values. Fill or drop NaN values first.
+
+## License
+
+MIT

sylearn-0.1.0/sylearn/__init__.py

@@ -0,0 +1,7 @@
+"""My from-scratch ML models (no sklearn inside)."""
+from sylearn.linear_regression import syLinearRegression
+from sylearn.decision_tree import Node, syDecisionTreeRegressor
+from sylearn.random_forest import syRandomForestRegressor
+
+__version__ = "0.1.0"
+__all__ = ["syLinearRegression", "Node", "syDecisionTreeRegressor", "syRandomForestRegressor"]

sylearn-0.1.0/sylearn/decision_tree.py

@@ -0,0 +1,98 @@
+import numpy as np
+
+
+class Node:
+    def __init__(self, feature=None,threshold=None,left=None,right=None,prediction=None):
+        self.feature = feature
+        self.threshold = threshold
+        self.left = left
+        self.right = right
+        self.prediction = prediction
+
+class syDecisionTreeRegressor:
+
+    def __init__(self, max_depth=5, min_samples_split=2):
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.root = None
+
+    def fit(self, X, y):
+        X = np.array(X)
+        y = np.array(y)
+        self.root = self.build_me_a_tree(X, y)
+        return self
+
+    def predict(self, X):
+        X = np.array(X)
+        predictions = []
+        for x in X:
+            predictions.append(self.predict_one(x, self.root))
+        return np.array(predictions)
+
+    def build_me_a_tree(self, X, y, depth=0):
+        if depth>=self.max_depth or len(y)< self.min_samples_split:
+            prediction =np.mean(y)
+            return Node(prediction=prediction)
+
+        feature, threshold = self.find_best_split(X, y)
+
+        if feature is None:
+            prediction = np.mean(y)
+            return Node(prediction=prediction)
+
+        left_mask = X[:, feature] <= threshold
+        right_mask = X[:, feature] > threshold
+
+        X_left = X[left_mask]
+        X_right = X[right_mask]
+        y_left = y[left_mask]
+        y_right = y[right_mask]
+
+        left_node = self.build_me_a_tree(X_left, y_left, depth + 1)
+        right_node = self.build_me_a_tree(X_right, y_right, depth + 1)
+
+        return Node(feature=feature, threshold=threshold, left=left_node, right=right_node)
+
+    def find_best_split(self, X, y):
+        best_mse = float("inf")
+        best_feature = None
+        best_threshold = None
+
+        for i in range(X.shape[1]):
+            values = np.unique(X[:, i])
+            thresholds = (values[:-1] + values[1:])/2
+            #This part is not optimized by me. For now I am goining with this unomptimized version
+            for threshold in thresholds:
+                left = X[:, i] <= threshold
+                right = X[:, i] > threshold
+
+                y_left = y[left]
+                y_right = y[right]
+
+                if len(y_left) == 0 or len(y_right) == 0:
+                    continue
+
+                mse_left = self.calculate_mse(y_left)
+                mse_right = self.calculate_mse(y_right)
+
+                weighted_mse = (len(y_left)/len(y))*mse_left + (len(y_right)/len(y))*mse_right
+
+                if weighted_mse < best_mse:
+                    best_mse = weighted_mse
+                    best_feature = i
+                    best_threshold = threshold
+
+        return best_feature, best_threshold
+
+    def calculate_mse(self, y):
+        mean = np.mean(y)
+        return np.mean((y-mean)**2)
+
+    def predict_one(self, x, node):
+        if node.prediction is not None:
+            return node.prediction
+
+        if x[node.feature] <= node.threshold:
+            return self.predict_one(x, node.left)
+        else:
+            return self.predict_one(x, node.right)

sylearn-0.1.0/sylearn/linear_regression.py

@@ -0,0 +1,24 @@
+import numpy as np
+
+
+class syLinearRegression:
+    """Linear Regression from scratch using OLS: w = pinv(X) @ y."""
+
+    def __init__(self):
+        self.weights = None
+        self.intercept_ = None
+
+    def fit(self, X, y):
+        npX = np.array(X)
+        npX = np.c_[np.ones(npX.shape[0]), npX]
+        npy = np.array(y)
+        # self.weights= np.linalg.inv((npX.T@ npX)) @ npX.T @ npy
+        mixed = np.linalg.pinv(npX) @ npy
+
+        self.intercept_ = mixed[0]
+        self.weights = mixed[1:]
+        return self.weights, self.intercept_
+
+    def predict(self, X):
+        npX = np.array(X)
+        return npX @ self.weights + self.intercept_

sylearn-0.1.0/sylearn/random_forest.py

@@ -0,0 +1,33 @@
+import numpy as np
+
+from sylearn.decision_tree import syDecisionTreeRegressor
+
+
+class syRandomForestRegressor:
+    """Random Forest from scratch: bagging over my own decision trees."""
+
+    def __init__(self, n_trees=10, max_depth=5):
+        self.n_trees = n_trees
+        self.max_depth = max_depth
+        self.trees = []
+
+    def fit(self, X, y):
+        X = np.array(X)
+        y = np.array(y)
+        self.trees = []
+        for i in range(self.n_trees):
+            ids = np.random.choice(len(X), len(X), replace=True)
+            X_new = X[ids]
+            y_new = y[ids]
+            tree = syDecisionTreeRegressor(max_depth=self.max_depth)
+            tree.fit(X_new, y_new)
+            self.trees.append(tree)
+        return self
+
+    def predict(self, X):
+        results = []
+        for tree in self.trees:
+            pred = tree.predict(X)
+            results.append(pred)
+        final = np.mean(results, axis=0)
+        return final