mathcoreml 0.1.0__tar.gz

mathcoreml-0.1.0/LICENSE

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

mathcoreml-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: mathcoreml
+Version: 0.1.0
+Summary: Mathematical Implementation of ML algorithms from scratch
+Author-email: Tigran <tigran.harutunyan.02@gmail.com>
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+Dynamic: license-file
+
+# MathCoreML
+
+Lightweight utilities and example models for small-scale machine learning experiments.
+
+## Overview
+
+**MathCoreML** is a compact Python library designed for learning, teaching, and rapid prototyping of small machine learning workflows.  
+The project emphasizes **clarity, simplicity, and minimal dependencies**, making it suitable for educational use and lightweight experiments.
+
+It provides:
+
+- Simple CSV data exploration utilities
+- Basic data cleaning helpers
+- Minimal reference implementations of classic ML models
+
+---
+
+## Features
+
+### 📊 Data Utilities
+
+- **CSVStore**
+    - Easy CSV loading
+    - Basic statistics (min, max, mean, counts)
+    - Quick summaries and simple visualizations
+- **CleanData**
+    - IQR-based outlier detection
+    - Lightweight data-cleaning helpers
+
+### 🤖 Models
+
+- **Linear Regression**
+- **Logistic Regression**
+
+These implementations are intentionally minimal and readable, aimed at education and experimentation rather than production-scale systems.
+
+---
+
+## Installation
+
+Install from PyPI (once published):
+
+```bash
+pip install mathcoreml
+```
+
+For local development:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+## Quick Start
+
+Example usage with CSVStore (provide your own CSV file):
+
+```python
+from MathCoreML.utils.CSVStore import CSVStore
+from MathCoreML.utils.CleanData import CleanData
+
+store = CSVStore('/absolute/path/to/your_dataset.csv')
+print('Rows:', len(store))
+print('Max Age:', store.max_of('Age'))
+
+store.quick_summary()
+```
+
+## Package Structure
+```text
+MathCoreML/
+├── src/
+│   └── mathcoreml/
+│       ├── Models/
+│       │   ├── linearRegression.py
+│       │   └── logisticRegression.py
+│       └── utils/
+│           ├── csvstore.py
+│           ├── cleandata.py
+│           └── modelevaluator.py
+└── pyproject.toml
+```
+## Notes
+
+### Designed for clarity and learning, not as a replacement for full ML frameworks.
+
+#### Public API is limited to modules inside MathCoreML.
+
+## License
+
+This project is licensed under the MIT License. See the `LICENSE` file for details.

mathcoreml-0.1.0/README.md

@@ -0,0 +1,92 @@
+# MathCoreML
+
+Lightweight utilities and example models for small-scale machine learning experiments.
+
+## Overview
+
+**MathCoreML** is a compact Python library designed for learning, teaching, and rapid prototyping of small machine learning workflows.  
+The project emphasizes **clarity, simplicity, and minimal dependencies**, making it suitable for educational use and lightweight experiments.
+
+It provides:
+
+- Simple CSV data exploration utilities
+- Basic data cleaning helpers
+- Minimal reference implementations of classic ML models
+
+---
+
+## Features
+
+### 📊 Data Utilities
+
+- **CSVStore**
+    - Easy CSV loading
+    - Basic statistics (min, max, mean, counts)
+    - Quick summaries and simple visualizations
+- **CleanData**
+    - IQR-based outlier detection
+    - Lightweight data-cleaning helpers
+
+### 🤖 Models
+
+- **Linear Regression**
+- **Logistic Regression**
+
+These implementations are intentionally minimal and readable, aimed at education and experimentation rather than production-scale systems.
+
+---
+
+## Installation
+
+Install from PyPI (once published):
+
+```bash
+pip install mathcoreml
+```
+
+For local development:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+## Quick Start
+
+Example usage with CSVStore (provide your own CSV file):
+
+```python
+from MathCoreML.utils.CSVStore import CSVStore
+from MathCoreML.utils.CleanData import CleanData
+
+store = CSVStore('/absolute/path/to/your_dataset.csv')
+print('Rows:', len(store))
+print('Max Age:', store.max_of('Age'))
+
+store.quick_summary()
+```
+
+## Package Structure
+```text
+MathCoreML/
+├── src/
+│   └── mathcoreml/
+│       ├── Models/
+│       │   ├── linearRegression.py
+│       │   └── logisticRegression.py
+│       └── utils/
+│           ├── csvstore.py
+│           ├── cleandata.py
+│           └── modelevaluator.py
+└── pyproject.toml
+```
+## Notes
+
+### Designed for clarity and learning, not as a replacement for full ML frameworks.
+
+#### Public API is limited to modules inside MathCoreML.
+
+## License
+
+This project is licensed under the MIT License. See the `LICENSE` file for details.

mathcoreml-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mathcoreml"
+version = "0.1.0"
+readme = "README.md"
+authors = [{name = "Tigran", email = "tigran.harutunyan.02@gmail.com"}]
+description = "Mathematical Implementation of ML algorithms from scratch"
+license = {text = "MIT"}
+dependencies = [
+    "numpy",
+    "pandas",
+    "matplotlib",
+    "scikit-learn"
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

mathcoreml-0.1.0/setup.cfg

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

mathcoreml-0.1.0/src/MathCoreML/Models/linearRegression.py

@@ -0,0 +1,95 @@
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model  import LinearRegression
+import matplotlib.pyplot as plt
+import mathcoreml.utils.csvstore as csvstore
+from mathcoreml.Models.template_models.modelImplementationTemplate import Models 
+from mathcoreml.utils.cleandata import cleandata
+from mathcoreml.utils.modelevalutaor import RegressionEvaluator
+class linear_regression(Models):
+    def __init__(self,object:csvstore):
+        self.model = LinearRegression()
+        self._df = object.frame
+        self.is_trained = False
+        self.is_preaper = False
+    def preaper_data(self,x_column,y_column):
+        """
+        Prepare data for model training by separating features and target.
+        
+        Args:
+            x_column: Column name to use as target variable (X)
+            y_column: Column name to use as target variable (Y)
+        
+        Returns:
+            None (prepares self.X and self.Y)
+        """
+        if self.is_preaper:
+            print("Your Data is preapered")
+            return 
+        q1_x = self._df[x_column].quantile(0.25)
+        q3_x = self._df[x_column].quantile(0.75)
+        q1_y = self._df[y_column].quantile(0.25)
+        q3_y = self._df[y_column].quantile(0.75)
+
+        self.__clean_data = cleandata(q1_x, q3_x, q1_y, q3_y)
+        mask_x = self._df[x_column].apply(lambda x: not self.__clean_data.x_is_outlier(x))
+        mask_y = self._df[y_column].apply(lambda y: not self.__clean_data.y_is_outlier(y))
+        self._df = self._df[mask_x & mask_y].copy()
+        self._df = self._df.dropna(subset=[x_column, y_column])
+        self._df = self._df.reset_index(drop=True)
+        self.X = self._df[[x_column]]
+        self.Y = self._df[y_column]
+        self.is_preaper = True
+    def train_model(self):
+        """
+        Train the  Lineary regression model using prepared data.
+        
+        Args:
+            None
+        
+        Returns:
+            float: Model accuracy score on test set
+        """
+        if self.is_trained:
+            print("Your Model is trained")
+            return
+        X_train,X_test,Y_train,Y_test = train_test_split(self.X,self.Y,test_size=0.2,train_size=0.8)
+        self.model.fit(X_train,Y_train)
+        self.is_trained = True
+        self.y_hat = self.model.predict(self.X)
+        return self.model.score(X_test,Y_test)
+    def predict_single(self, index):
+        """
+        Predict the probability for a single sample at given index.
+        
+        Args:
+            index: Row index in the dataset (0-based)
+        
+        Returns:
+            float: Predicted probability of the positive class (0-1)
+        """
+        if index < 0  or index >  len(self._df):
+            print("Invalid Index")
+            return 0
+        return self.model.predict(self.X.iloc[[index]])[0]
+    def plot_regression(self):
+        plt.figure()
+        plt.scatter(self.X,self.Y,color='black')
+        self._slope = self.model.coef_[0]
+        self.intercept = self.model.intercept_
+        y_line = self._slope * self.X + self.intercept
+        plt.plot(self.X,y_line,color='red',label="Regression line")
+        plt.xlabel(self.X.columns[0])
+        plt.ylabel(self.Y.name)
+        plt.title(f"{self.X.columns[0]} and {self.Y.name} regressoin graph")
+        plt.tight_layout()
+        plt.show()
+    def compare_dataset(self):
+        evaluator = RegressionEvaluator(self.X,self.y_hat)
+        evaluator.get_all_metrics()
+        evaluator.print_metrics()
+        ess ,rss,tss = evaluator.calculate_sum_of_squares()
+        print(f"ESS:{ess}")
+        print(f"RSS:{rss}")
+        print(f"TSS:{tss}")
+
+        

mathcoreml-0.1.0/src/MathCoreML/Models/logisticRegression.py

@@ -0,0 +1,100 @@
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import train_test_split
+import matplotlib.pyplot as plt
+import numpy as np
+import mathcoreml.utils.csvstore as csvstore
+from mathcoreml.Models.template_models.modelImplementationTemplate import  Models
+class logistic_regression(Models):
+    def __init__(self,dataset_object:csvstore):
+        """
+        Initialize logistic regression model with a dataset.
+        
+        Args:
+            dataset_object: csvstore object containing the dataset
+        
+        Returns:
+            None
+        """
+        self.model = LogisticRegression(max_iter=1000)
+        self._df = dataset_object.frame
+        self.is_trained = False
+        self.is_preaper = False
+    def preaper_data(self,x_column):
+        """
+        Prepare data for model training by separating features and target.
+        
+        Args:
+            x_column: Column name to use as target variable (Y)
+        
+        Returns:
+            None (prepares self.X and self.Y)
+        """
+        if self.is_preaper:
+            print("Your  Data is preapered")
+            return 
+        self.X = self._df.drop(x_column,axis=1)
+        self.Y = self._df[x_column]
+        self.is_preaper = True
+    def train_model(self):
+        """
+        Train the logistic regression model using prepared data.
+        
+        Args:
+            None
+        
+        Returns:
+            float: Model accuracy score on test set
+        """
+        if self.is_trained:
+            print("Your Model is tarined")
+            return
+        X_train , X_test , Y_train  , Y_test  = train_test_split(self.X,self.Y,test_size=0.2,train_size=0.7)
+        self.model.fit(X_train,Y_train)
+        self.is_trained = True
+        return self.model.score(X_test,Y_test)
+    def predict_single(self,index:int):
+        """
+        Predict the probability for a single sample at given index.
+        
+        Args:
+            index: Row index in the dataset (0-based)
+        
+        Returns:
+            float: Predicted probability of the positive class (0-1)
+        """
+        if index < 0  or index >  len(self._df):
+            print("Invalid Index")
+            return 0
+        row_df = self.X.iloc[[index]]
+        print(row_df)
+        return self.model.predict_proba(row_df)[0][1]    
+    def plot_my_model_sigmoid(self):
+        """
+        Visualize the logistic regression sigmoid curve with predictions.
+        
+        Args:
+            None
+        
+        Returns:
+            None (displays sigmoid curve plot)
+        """
+        z_values = self.model.decision_function(self.X)
+        probs = self.model.predict_proba(self.X)[:, 1]
+    
+        z_range = np.linspace(z_values.min() - 1, z_values.max() + 1, 100)
+        sigmoid_curve = 1 / (1 + np.exp(-z_range))
+        
+        plt.figure(figsize=(10, 6))
+        plt.plot(z_range, sigmoid_curve, color='blue', alpha=0.5, label='Sigmoid Curve')
+        
+        plt.scatter(z_values, probs, c=probs, cmap='RdYlGn_r', edgecolors='black', s=40)
+        
+        plt.axhline(0.5, color='red', linestyle='--', label='Threshold (0.5)')
+        plt.axvline(0, color='black', alpha=0.3)
+        
+        plt.title('My Logistic Regression Sigmoid')
+        plt.xlabel('z')
+        plt.ylabel('Probabilty')
+        plt.legend()
+        plt.grid(True, alpha=0.2)
+        plt.show()

mathcoreml-0.1.0/src/MathCoreML/Models/template_models/modelImplementationTemplate.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+class Models(ABC):
+    @abstractmethod
+    def preaper_data(self,x_column):
+        pass
+    @abstractmethod
+    def train_model(self):
+        pass
+    @abstractmethod
+    def predict_single(self,index:int):
+        pass
+    

mathcoreml-0.1.0/src/MathCoreML/utils/cleandata.py

@@ -0,0 +1,122 @@
+class cleandata:
+    def __init__(self, x_q1, x_q3, y_q1, y_q3):
+        """
+        Initialize CleanData with quartile values for outlier detection.
+        
+        Args:
+            x_q1: First quartile (25th percentile) value for X
+            x_q3: Third quartile (75th percentile) value for X
+            y_q1: First quartile (25th percentile) value for Y
+            y_q3: Third quartile (75th percentile) value for Y
+        
+        Returns:
+            None
+        """
+        # Store X quartile values for X dimension outlier detection
+        self._x_q1 = x_q1
+        self._x_q3 = x_q3
+        # Store Y quartile values for Y dimension outlier detection
+        self._y_q1 = y_q1
+        self._y_q3 = y_q3
+    @property
+    def x_iqr(self) -> float:
+        """
+        Get the Interquartile Range (IQR) of X.
+        
+        IQR = Q3 - Q1, represents the middle 50% of data spread.
+        Used in the IQR method for outlier detection.
+        
+        Returns:
+            float: The IQR value (Q3 - Q1)
+        """
+        return self._x_q3 - self._x_q1
+    @property
+    def y_iqr(self) -> float:
+        """
+        Get the Interquartile Range (IQR) of Y.
+        
+        IQR = Q3 - Q1, represents the middle 50% of data spread.
+        Used in the IQR method for outlier detection.
+        
+        Returns:
+            float: The IQR value (Q3 - Q1)
+        """
+        return self._y_q3 - self._y_q1
+    @property
+    def x_lower_bound(self) -> float:
+        """
+        Get the lower bound for X outlier detection.
+        
+        Uses IQR method: Lower Bound = Q1 - 1.5 * IQR
+        Values below this bound are considered outliers.
+        
+        Returns:
+            float: Lower bound calculated as Q1 - 1.5 * IQR
+        """
+        return self._x_q1 - 1.5 * self.x_iqr
+    @property
+    def x_upper_bound(self) -> float:
+        """
+        Get the upper bound for X outlier detection.
+        
+        Uses IQR method: Upper Bound = Q3 + 1.5 * IQR
+        Values above this bound are considered outliers.
+        
+        Returns:
+            float: Upper bound calculated as Q3 + 1.5 * IQR
+        """
+        return self._x_q3 + 1.5 * self.x_iqr
+    @property
+    def y_lower_bound(self) -> float:
+        """
+        Get the lower bound for Y outlier detection.
+        
+        Uses IQR method: Lower Bound = Q1 - 1.5 * IQR
+        Values below this bound are considered outliers.
+        
+        Returns:
+            float: Lower bound calculated as Q1 - 1.5 * IQR
+        """
+        return self._y_q1 - 1.5 * self.y_iqr
+    @property
+    def y_upper_bound(self) -> float:
+        """
+        Get the upper bound for Y outlier detection.
+        
+        Uses IQR method: Upper Bound = Q3 + 1.5 * IQR
+        Values above this bound are considered outliers.
+        
+        Returns:
+            float: Upper bound calculated as Q3 + 1.5 * IQR
+        """
+        return self._y_q3 + 1.5 * self.y_iqr
+    def y_is_outlier(self, value) -> bool:
+        """
+        Check if a Y value is an outlier using the IQR method.
+        
+        An outlier is any value that falls outside the bounds:
+        (value < lower_bound) or (value > upper_bound)
+        
+        Args:
+            value: The Y value to check
+        
+        Returns:
+            bool: True if value is outside the bounds (outlier), False otherwise
+        """
+        return (value < self.y_lower_bound) or (value > self.y_upper_bound)
+    def x_is_outlier(self, value) -> bool:
+        """
+        Check if an X value is an outlier using the IQR method.
+        
+        An outlier is any value that falls outside the bounds:
+        (value < lower_bound) or (value > upper_bound)
+        
+        Args:
+            value: The X value to check
+        
+        Returns:
+            bool: True if value is outside the bounds (outlier), False otherwise
+        """
+        return (value < self.x_lower_bound) or (value > self.x_upper_bound)
+        
+