avish-lib 0.1.0__tar.gz

avish_lib-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Avish
+
+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.

avish_lib-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: avish_lib
+Version: 0.1.0
+Summary: Lightweight custom ML algorithms library (avish_lib)
+Home-page: https://github.com/yourusername/avish_lib
+Author: Avish
+Project-URL: Homepage, https://github.com/yourusername/avish_lib
+Project-URL: Repository, https://github.com/yourusername/avish_lib
+Project-URL: Documentation, https://github.com/yourusername/avish_lib#readme
+Keywords: machine learning,regression,pca,numpy,ml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# avish_lib
+
+avish_lib is a small collection of custom machine-learning algorithms implemented with minimal dependencies (NumPy).
+
+Install for local development:
+
+```bash
+python -m pip install -e .
+```
+
+Quick usage:
+
+```python
+from avish_lib import LinearRegression, RidgeRegression, KNNRegressor, PCA
+
+# Simple linear fit
+X = [[1], [2], [3], [4]]
+y = [2, 4, 6, 8]
+model = LinearRegression()
+model.fit(X, y)
+print("coef:", model.coef_, "intercept:", model.intercept_)
+
+# PCA example
+p = PCA(n_components=1)
+X_reduced = p.fit_transform([[1,2],[3,4],[5,6]])
+print(X_reduced)
+```
+
+Project layout:
+
+```
+your_project_name/
+├── src/
+│   └── avish_lib/
+│       ├── __init__.py
+│       └── linear_models.py
+├── tests/
+├── pyproject.toml
+├── README.md
+└── LICENSE
+```

avish_lib-0.1.0/README.md

@@ -0,0 +1,41 @@
+# avish_lib
+
+avish_lib is a small collection of custom machine-learning algorithms implemented with minimal dependencies (NumPy).
+
+Install for local development:
+
+```bash
+python -m pip install -e .
+```
+
+Quick usage:
+
+```python
+from avish_lib import LinearRegression, RidgeRegression, KNNRegressor, PCA
+
+# Simple linear fit
+X = [[1], [2], [3], [4]]
+y = [2, 4, 6, 8]
+model = LinearRegression()
+model.fit(X, y)
+print("coef:", model.coef_, "intercept:", model.intercept_)
+
+# PCA example
+p = PCA(n_components=1)
+X_reduced = p.fit_transform([[1,2],[3,4],[5,6]])
+print(X_reduced)
+```
+
+Project layout:
+
+```
+your_project_name/
+├── src/
+│   └── avish_lib/
+│       ├── __init__.py
+│       └── linear_models.py
+├── tests/
+├── pyproject.toml
+├── README.md
+└── LICENSE
+```

avish_lib-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "avish_lib"
+version = "0.1.0"
+description = "Lightweight custom ML algorithms library (avish_lib)"
+authors = [ { name = "Avish" } ]
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = ["numpy>=1.21"]
+keywords = ["machine learning", "regression", "pca", "numpy", "ml"]
+classifiers = [
+	"Development Status :: 4 - Beta",
+	"Intended Audience :: Developers",
+	"License :: OSI Approved :: MIT License",
+	"Programming Language :: Python :: 3",
+	"Programming Language :: Python :: 3.8",
+	"Programming Language :: Python :: 3.9",
+	"Programming Language :: Python :: 3.10",
+	"Programming Language :: Python :: 3.11",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/avish_lib"
+Repository = "https://github.com/yourusername/avish_lib"
+Documentation = "https://github.com/yourusername/avish_lib#readme"
+
+[tool.pytest.ini_options]
+addopts = "-q"

avish_lib-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

avish_lib-0.1.0/setup.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+"""
+Alternative setup.py for avish_lib (complements pyproject.toml).
+This is optional but provides backward compatibility.
+"""
+
+from setuptools import setup, find_packages
+
+setup(
+    name="avish_lib",
+    version="0.1.0",
+    description="Lightweight custom ML algorithms library",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    author="Avish",
+    url="https://github.com/yourusername/avish_lib",  # Update this
+    license="MIT",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    python_requires=">=3.8",
+    install_requires=["numpy>=1.21"],
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+    ],
+)

avish_lib-0.1.0/src/avish_lib/__init__.py

@@ -0,0 +1,22 @@
+"""avish_lib package — lightweight custom ML algorithms.
+
+Expose core models for easy importing:
+
+from avish_lib import LinearRegression, RidgeRegression, KNNRegressor, PCA
+"""
+
+from .linear_models import (
+    LinearRegression,
+    RidgeRegression,
+    LassoRegression,
+    KNNRegressor,
+    PCA,
+)
+
+__all__ = [
+    "LinearRegression",
+    "RidgeRegression",
+    "LassoRegression",
+    "KNNRegressor",
+    "PCA",
+]

avish_lib-0.1.0/src/avish_lib/linear_models.py

@@ -0,0 +1,187 @@
+"""Minimal implementations of a few algorithms for avish_lib.
+
+This file intentionally keeps implementations small and dependency-light (only numpy).
+"""
+
+from typing import Optional
+import numpy as np
+
+
+class LinearRegression:
+    """Ordinary Least Squares linear regression using the normal equation."""
+
+    def __init__(self, fit_intercept: bool = True):
+        self.fit_intercept = fit_intercept
+        self.coef_ = None
+        self.intercept_ = 0.0
+
+    def fit(self, X, y):
+        X = np.asarray(X, dtype=float)
+        y = np.asarray(y, dtype=float)
+        if X.ndim == 1:
+            X = X.reshape(-1, 1)
+        if self.fit_intercept:
+            X_design = np.hstack([np.ones((X.shape[0], 1)), X])
+        else:
+            X_design = X
+        # Normal equation with pseudo-inverse for stability
+        theta = np.linalg.pinv(X_design.T.dot(X_design)).dot(X_design.T).dot(y)
+        if self.fit_intercept:
+            self.intercept_ = float(theta[0])
+            self.coef_ = theta[1:]
+        else:
+            self.coef_ = theta
+            self.intercept_ = 0.0
+        return self
+
+    def predict(self, X):
+        X = np.asarray(X, dtype=float)
+        if X.ndim == 1:
+            X = X.reshape(-1, 1)
+        return (X.dot(self.coef_) + self.intercept_).astype(float)
+
+
+class RidgeRegression(LinearRegression):
+    """Closed-form Ridge regression (L2) using normal equation.
+
+    alpha: regularization strength (>=0)
+    """
+
+    def __init__(self, alpha: float = 1.0, fit_intercept: bool = True):
+        super().__init__(fit_intercept=fit_intercept)
+        self.alpha = alpha
+
+    def fit(self, X, y):
+        X = np.asarray(X, dtype=float)
+        y = np.asarray(y, dtype=float)
+        if X.ndim == 1:
+            X = X.reshape(-1, 1)
+        if self.fit_intercept:
+            X_design = np.hstack([np.ones((X.shape[0], 1)), X])
+        else:
+            X_design = X
+        n_features = X_design.shape[1]
+        A = X_design.T.dot(X_design)
+        # Regularize bias if fit_intercept=False; otherwise don't regularize bias column
+        reg = self.alpha * np.eye(n_features)
+        if self.fit_intercept:
+            reg[0, 0] = 0.0
+        theta = np.linalg.inv(A + reg).dot(X_design.T).dot(y)
+        if self.fit_intercept:
+            self.intercept_ = float(theta[0])
+            self.coef_ = theta[1:]
+        else:
+            self.coef_ = theta
+            self.intercept_ = 0.0
+        return self
+
+
+class LassoRegression:
+    """A simple Lasso implementation using iterative soft-thresholding (ISTA).
+
+    Note: This is a small-scale implementation intended for educational use.
+    """
+
+    def __init__(self, alpha: float = 1.0, lr: float = 1e-3, iterations: int = 1000, fit_intercept: bool = True):
+        self.alpha = alpha
+        self.lr = lr
+        self.iterations = iterations
+        self.fit_intercept = fit_intercept
+        self.coef_ = None
+        self.intercept_ = 0.0
+
+    def _soft_threshold(self, x, thresh):
+        return np.sign(x) * np.maximum(np.abs(x) - thresh, 0.0)
+
+    def fit(self, X, y):
+        X = np.asarray(X, dtype=float)
+        y = np.asarray(y, dtype=float)
+        if X.ndim == 1:
+            X = X.reshape(-1, 1)
+        n_samples, n_features = X.shape
+        if self.fit_intercept:
+            X_design = np.hstack([np.ones((n_samples, 1)), X])
+        else:
+            X_design = X
+        # initialize
+        theta = np.zeros(X_design.shape[1])
+        L = np.linalg.norm(X_design, ord=2) ** 2 / n_samples
+        if L == 0:
+            L = 1.0
+        t = 1.0 / L
+        for _ in range(self.iterations):
+            grad = (1.0 / n_samples) * X_design.T.dot(X_design.dot(theta) - y)
+            theta = theta - t * grad
+            # apply soft-threshold to non-bias terms
+            if self.fit_intercept:
+                theta[1:] = self._soft_threshold(theta[1:], t * self.alpha)
+            else:
+                theta = self._soft_threshold(theta, t * self.alpha)
+        if self.fit_intercept:
+            self.intercept_ = float(theta[0])
+            self.coef_ = theta[1:]
+        else:
+            self.coef_ = theta
+            self.intercept_ = 0.0
+        return self
+
+    def predict(self, X):
+        X = np.asarray(X, dtype=float)
+        if X.ndim == 1:
+            X = X.reshape(-1, 1)
+        return (X.dot(self.coef_) + self.intercept_).astype(float)
+
+
+class KNNRegressor:
+    """Simple k-NN regressor using Euclidean distance."""
+
+    def __init__(self, k: int = 5):
+        self.k = max(1, int(k))
+        self.X_train = None
+        self.y_train = None
+
+    def fit(self, X, y):
+        X = np.asarray(X, dtype=float)
+        if X.ndim == 1:
+            X = X.reshape(-1, 1)
+        self.X_train = X
+        self.y_train = np.asarray(y, dtype=float)
+        return self
+
+    def predict(self, X):
+        X = np.asarray(X, dtype=float)
+        if X.ndim == 1:
+            X = X.reshape(-1, 1)
+        preds = []
+        for x in X:
+            dists = np.linalg.norm(self.X_train - x, axis=1)
+            idx = np.argsort(dists)[: self.k]
+            preds.append(np.mean(self.y_train[idx]))
+        return np.array(preds)
+
+
+class PCA:
+    """Principal Component Analysis using SVD."""
+
+    def __init__(self, n_components: Optional[int] = None):
+        self.n_components = n_components
+        self.components_ = None
+        self.mean_ = None
+
+    def fit(self, X):
+        X = np.asarray(X, dtype=float)
+        self.mean_ = np.mean(X, axis=0)
+        Xc = X - self.mean_
+        U, S, Vt = np.linalg.svd(Xc, full_matrices=False)
+        if self.n_components is None:
+            self.n_components = Vt.shape[0]
+        self.components_ = Vt[: self.n_components]
+        return self
+
+    def transform(self, X):
+        X = np.asarray(X, dtype=float)
+        return (X - self.mean_).dot(self.components_.T)
+
+    def fit_transform(self, X):
+        self.fit(X)
+        return self.transform(X)

avish_lib-0.1.0/src/avish_lib.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: avish_lib
+Version: 0.1.0
+Summary: Lightweight custom ML algorithms library (avish_lib)
+Home-page: https://github.com/yourusername/avish_lib
+Author: Avish
+Project-URL: Homepage, https://github.com/yourusername/avish_lib
+Project-URL: Repository, https://github.com/yourusername/avish_lib
+Project-URL: Documentation, https://github.com/yourusername/avish_lib#readme
+Keywords: machine learning,regression,pca,numpy,ml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# avish_lib
+
+avish_lib is a small collection of custom machine-learning algorithms implemented with minimal dependencies (NumPy).
+
+Install for local development:
+
+```bash
+python -m pip install -e .
+```
+
+Quick usage:
+
+```python
+from avish_lib import LinearRegression, RidgeRegression, KNNRegressor, PCA
+
+# Simple linear fit
+X = [[1], [2], [3], [4]]
+y = [2, 4, 6, 8]
+model = LinearRegression()
+model.fit(X, y)
+print("coef:", model.coef_, "intercept:", model.intercept_)
+
+# PCA example
+p = PCA(n_components=1)
+X_reduced = p.fit_transform([[1,2],[3,4],[5,6]])
+print(X_reduced)
+```
+
+Project layout:
+
+```
+your_project_name/
+├── src/
+│   └── avish_lib/
+│       ├── __init__.py
+│       └── linear_models.py
+├── tests/
+├── pyproject.toml
+├── README.md
+└── LICENSE
+```

avish_lib-0.1.0/src/avish_lib.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/avish_lib/__init__.py
+src/avish_lib/linear_models.py
+src/avish_lib.egg-info/PKG-INFO
+src/avish_lib.egg-info/SOURCES.txt
+src/avish_lib.egg-info/dependency_links.txt
+src/avish_lib.egg-info/requires.txt
+src/avish_lib.egg-info/top_level.txt
+tests/test_basic.py

avish_lib-0.1.0/src/avish_lib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

avish_lib-0.1.0/src/avish_lib.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.21

avish_lib-0.1.0/src/avish_lib.egg-info/top_level.txt

@@ -0,0 +1 @@
+avish_lib

avish_lib-0.1.0/tests/test_basic.py

@@ -0,0 +1,15 @@
+import math
+from avish_lib import LinearRegression
+
+
+def test_linear_regression_simple():
+    X = [[1], [2], [3], [4]]
+    y = [2, 4, 6, 8]
+    model = LinearRegression()
+    model.fit(X, y)
+    preds = model.predict(X)
+    # Expect near perfect fit: slope ~2, intercept ~0
+    assert math.isclose(model.coef_[0], 2.0, rel_tol=1e-6)
+    assert math.isclose(model.intercept_, 0.0, abs_tol=1e-6)
+    for p, t in zip(preds, y):
+        assert math.isclose(p, t, rel_tol=1e-6)