my-python-lib-tarik 0.1.0__tar.gz

my_python_lib_tarik-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: my_python_lib-tarik
+Version: 0.1.0
+Summary: A modular, object-oriented framework for machine learning and data preprocessing
+Author-email: Mustafa Tarık Kocabıyık <mtarikkb@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=2.4.4
+Requires-Dist: pandas>=3.0.2
+
+# Machine Learning & Data Preprocessing Library
+
+## Introduction
+
+This is a simple machine learning algorithm library consists of Linear Regression , KNN Classifier and some other data processing algorithms from scratch based on numpy and pandas libraries.
+
+---
+
+##  Mapping Core Learning Outcomes
+
+The 6 required patterns were applied appropriately in the project. Every single one is explained below.
+
+### 1. Object-Oriented Programming (OOP)
+- **Where**: In `core.py` and `data.py`.
+- **How**: 
+  - **Inheritance & Abstraction**: Employs abstract base classes (`BaseAlgorithm`, `RegressionStrategy`, `DistanceMetric`, `DataLoader`, `DataCreator`, `ImputeStrategy`, `EncodingStrategy`) to enforce blueprints.
+  - **Polymorphism**: Concrete implementations dynamically substitute base behavior. For example, `LinearRegression` executes `.train()` polymorphic actions via different assigned regression strategies without altering its own structure.
+  - **Encapsulation**: State variables are protected internally. In `data.py`, the raw dataframe is hidden behind a protected attribute `self._data` and managed safely using the `@property` getter.
+
+### 2. Functional Programming
+- **Where**: In `core.py` and `utils.py`.
+- **How**:
+  - **Pure Functions & Lambda**: `evaluate_model` avoids modifying external states and relies entirely on input arguments, calculating mean squared errors via a clean pure lambda routine.
+  - **Higher-Order Functions & Map/Reduce**:
+    - `reduce` combined with `lambda` is used inside `evaluate_model` to sum squared errors.
+    - `map` is used inside `series_to_ndarray` to cast panda series rows to float representations.
+    - `apply_pipeline` utilizes `reduce` to sequentially compose list-based transformation callables across data boundaries (`reduce(lambda d, func: func(d), transformations, data)`).
+
+### 3. Concurrency (Multi-threading)
+- **Where**: Implemented in `core.py` inside the `KNNClassifier` class.
+- **How**: 
+  - Predicting classes for massive feature maps sequentially is computationally bound. The `predict` method generates individual `threading.Thread` operations for every distinct evaluation sample.
+  - The `_predict_single` worker calculates specific row-by-row matrix operations concurrently, storing structural outputs inside a shared pre-allocated numpy results matrix (`results[index]`).
+  - Thread control structures utilize `t.start()` loops followed by systematic `t.join()` barriers to synchronize and block primary execution until parallel estimations conclude safely.
+
+### 4. Recursion / Dynamic Programming
+- **Where**: In `core.py` inside the `EuclideanDistance` class.
+- **How**:
+  - Distance metrics typically resolve dimensions via nested iterative syntax or high-level library functions. This implementation achieves element-wise vector difference accumulations via a custom recursive function `recursive_sum_sq(a, b, idx)`.
+  - It recursively accumulates squared parameter differences index-by-index until it reaches the base case (`idx == len(a)`), gracefully returning the final structural matrix sqrt reduction.
+
+### 5. SOLID Principles
+- **Where**: In `core.py` and `data.py`.
+- **How**:
+  - **Single Responsibility Principle (SRP)**: Classes do exactly one thing. `CSVLoader` only ingests data streams; `MeanImputer` strictly provides missing value fillings; `DataProcessor` focuses on data manipulation.
+  - **Open/Closed Principle (OCP)**: The system is open for extension but closed for modification. Introducing a new distance metric (e.g., Cosine Distance) requires subclassing `DistanceMetric` without touching `KNNClassifier`.
+  - **Liskov Substitution Principle (LSP)**: Derived classes are completely interchangeable with their abstractions. Any encoder (`LabelEncoder`, `OneHotEncoder`, `TargetEncoder`) fulfills the signature constraints expected by `DataProcessor`.
+  - **Interface Segregation Principle (ISP)**: Interfaces remain lean and decoupled. `RegressionStrategy` enforces a single clear contractual point (`train`), avoiding bulky, unrelated structural configurations.
+  - **Dependency Inversion Principle (DIP)**: High-level objects depend on abstractions rather than low-level concrete modules. `LinearRegression` binds entirely against the `RegressionStrategy` interface, decoupling model training mechanisms from specific analytical algorithms.
+
+### 6. Architectural & Design Patterns
+- **Where**: Full design of `data.py` and `core.py`.
+- **How**:
+  - **Pipeline Architecture**: Managed by `DataPipeline` which neatly bridges file checking, concrete factory creation, loading, and structured feature preparation routines into a uniform linear API stream (`run_default_preprocessing`).
+  - **Strategy Pattern**: Implemented multiple times to provide interchangeable components:
+    - Optimization algorithms in `LinearRegression` via `LeastSquaresStrategy` and `GradientDescentStrategy`.
+    - Distance formulations in `KNNClassifier` via `EuclideanDistance` and `ManhattanDistance`.
+    - Data imputation in `DataProcessor` via `MeanImputer`, `MedianImputer`, and `ModeImputer`.
+    - Variable transformations via `LabelEncoder`, `OneHotEncoder`, and `TargetEncoder`.
+  - **Factory Method Pattern**: Used to create appropriate data loaders without binding to concrete files. `DataCreator` acts as the creator interface, declaring `create_document()`. Concrete implementations `CSVCreator` and `JSONCreator` override this method to instantiate and return `CSVLoader` or `JSONLoader` respectively, abstracting the instantiation process away from the main pipeline.

my_python_lib_tarik-0.1.0/README.md

@@ -0,0 +1,60 @@
+# Machine Learning & Data Preprocessing Library
+
+## Introduction
+
+This is a simple machine learning algorithm library consists of Linear Regression , KNN Classifier and some other data processing algorithms from scratch based on numpy and pandas libraries.
+
+---
+
+##  Mapping Core Learning Outcomes
+
+The 6 required patterns were applied appropriately in the project. Every single one is explained below.
+
+### 1. Object-Oriented Programming (OOP)
+- **Where**: In `core.py` and `data.py`.
+- **How**: 
+  - **Inheritance & Abstraction**: Employs abstract base classes (`BaseAlgorithm`, `RegressionStrategy`, `DistanceMetric`, `DataLoader`, `DataCreator`, `ImputeStrategy`, `EncodingStrategy`) to enforce blueprints.
+  - **Polymorphism**: Concrete implementations dynamically substitute base behavior. For example, `LinearRegression` executes `.train()` polymorphic actions via different assigned regression strategies without altering its own structure.
+  - **Encapsulation**: State variables are protected internally. In `data.py`, the raw dataframe is hidden behind a protected attribute `self._data` and managed safely using the `@property` getter.
+
+### 2. Functional Programming
+- **Where**: In `core.py` and `utils.py`.
+- **How**:
+  - **Pure Functions & Lambda**: `evaluate_model` avoids modifying external states and relies entirely on input arguments, calculating mean squared errors via a clean pure lambda routine.
+  - **Higher-Order Functions & Map/Reduce**:
+    - `reduce` combined with `lambda` is used inside `evaluate_model` to sum squared errors.
+    - `map` is used inside `series_to_ndarray` to cast panda series rows to float representations.
+    - `apply_pipeline` utilizes `reduce` to sequentially compose list-based transformation callables across data boundaries (`reduce(lambda d, func: func(d), transformations, data)`).
+
+### 3. Concurrency (Multi-threading)
+- **Where**: Implemented in `core.py` inside the `KNNClassifier` class.
+- **How**: 
+  - Predicting classes for massive feature maps sequentially is computationally bound. The `predict` method generates individual `threading.Thread` operations for every distinct evaluation sample.
+  - The `_predict_single` worker calculates specific row-by-row matrix operations concurrently, storing structural outputs inside a shared pre-allocated numpy results matrix (`results[index]`).
+  - Thread control structures utilize `t.start()` loops followed by systematic `t.join()` barriers to synchronize and block primary execution until parallel estimations conclude safely.
+
+### 4. Recursion / Dynamic Programming
+- **Where**: In `core.py` inside the `EuclideanDistance` class.
+- **How**:
+  - Distance metrics typically resolve dimensions via nested iterative syntax or high-level library functions. This implementation achieves element-wise vector difference accumulations via a custom recursive function `recursive_sum_sq(a, b, idx)`.
+  - It recursively accumulates squared parameter differences index-by-index until it reaches the base case (`idx == len(a)`), gracefully returning the final structural matrix sqrt reduction.
+
+### 5. SOLID Principles
+- **Where**: In `core.py` and `data.py`.
+- **How**:
+  - **Single Responsibility Principle (SRP)**: Classes do exactly one thing. `CSVLoader` only ingests data streams; `MeanImputer` strictly provides missing value fillings; `DataProcessor` focuses on data manipulation.
+  - **Open/Closed Principle (OCP)**: The system is open for extension but closed for modification. Introducing a new distance metric (e.g., Cosine Distance) requires subclassing `DistanceMetric` without touching `KNNClassifier`.
+  - **Liskov Substitution Principle (LSP)**: Derived classes are completely interchangeable with their abstractions. Any encoder (`LabelEncoder`, `OneHotEncoder`, `TargetEncoder`) fulfills the signature constraints expected by `DataProcessor`.
+  - **Interface Segregation Principle (ISP)**: Interfaces remain lean and decoupled. `RegressionStrategy` enforces a single clear contractual point (`train`), avoiding bulky, unrelated structural configurations.
+  - **Dependency Inversion Principle (DIP)**: High-level objects depend on abstractions rather than low-level concrete modules. `LinearRegression` binds entirely against the `RegressionStrategy` interface, decoupling model training mechanisms from specific analytical algorithms.
+
+### 6. Architectural & Design Patterns
+- **Where**: Full design of `data.py` and `core.py`.
+- **How**:
+  - **Pipeline Architecture**: Managed by `DataPipeline` which neatly bridges file checking, concrete factory creation, loading, and structured feature preparation routines into a uniform linear API stream (`run_default_preprocessing`).
+  - **Strategy Pattern**: Implemented multiple times to provide interchangeable components:
+    - Optimization algorithms in `LinearRegression` via `LeastSquaresStrategy` and `GradientDescentStrategy`.
+    - Distance formulations in `KNNClassifier` via `EuclideanDistance` and `ManhattanDistance`.
+    - Data imputation in `DataProcessor` via `MeanImputer`, `MedianImputer`, and `ModeImputer`.
+    - Variable transformations via `LabelEncoder`, `OneHotEncoder`, and `TargetEncoder`.
+  - **Factory Method Pattern**: Used to create appropriate data loaders without binding to concrete files. `DataCreator` acts as the creator interface, declaring `create_document()`. Concrete implementations `CSVCreator` and `JSONCreator` override this method to instantiate and return `CSVLoader` or `JSONLoader` respectively, abstracting the instantiation process away from the main pipeline.

my_python_lib_tarik-0.1.0/my_python_lib/__init__.py

@@ -0,0 +1,82 @@
+"""
+my_python_lib: A custom Machine Learning and Data Preprocessing library.
+"""
+
+from .core import (
+    LinearRegression,
+    LeastSquaresStrategy,
+    GradientDescentStrategy,
+    KNNClassifier,
+    EuclideanDistance,
+    ManhattanDistance,
+    evaluate_model,
+)
+
+from .data import (
+    DataPipeline,
+    DataProcessor,
+    CSVCreator,
+    JSONCreator,
+    MeanImputer,
+    MedianImputer,
+    ModeImputer,
+    UnknownImputer,
+    LabelEncoder,
+    OneHotEncoder,
+    TargetEncoder,
+)
+
+from .utils import (
+    calculate_missing_values,
+    predict_stats,
+    predict_success_summary,
+    calculate_accuracy,
+    shuffle_data,
+    series_to_ndarray,
+    list_to_ndarray,
+    dimension_control,
+    data_summary,
+    log_operation,
+    apply_pipeline,
+    is_categorical,
+    NotCategoricalError,
+    is_multiple_mode,
+    ColumnNotFoundError,
+    numeric_check
+)
+
+__all__ = [
+    # Core Algorithms & Metrics
+    "LinearRegression",
+    "LeastSquaresStrategy",
+    "GradientDescentStrategy",
+    "KNNClassifier",
+    "EuclideanDistance",
+    "ManhattanDistance",
+    "evaluate_model",
+
+    # Data Pipeline & Processing
+    "DataPipeline",
+    "DataProcessor",
+    "CSVCreator",
+    "JSONCreator",
+    "MeanImputer",
+    "MedianImputer",
+    "ModeImputer",
+    "UnknownImputer",
+    "LabelEncoder",
+    "OneHotEncoder",
+    "TargetEncoder",
+
+    # Utilities
+    "calculate_missing_values",
+    "predict_stats",
+    "predict_success_summary",
+    "calculate_accuracy",
+    "shuffle_data",
+    "is_categorical",
+    "NotCategoricalError",
+    "is_multiple_mode",
+    "ColumnNotFoundError",
+    "numeric_check"
+]

my_python_lib_tarik-0.1.0/my_python_lib/core.py

@@ -0,0 +1,132 @@
+from abc import ABC, abstractmethod
+import threading
+import numpy as np
+from functools import reduce
+from my_python_lib.utils import dimension_control
+
+
+class BaseAlgorithm(ABC):
+    def __init__(self):
+        self.model_data = {}
+
+    @abstractmethod
+    def fit(self):
+        pass
+
+    @abstractmethod
+    def predict(self):
+        pass
+
+class RegressionStrategy(ABC):
+    @abstractmethod
+    def train(self):
+        pass
+
+class LeastSquaresStrategy(RegressionStrategy):
+    def train(self,X,y):
+        XTX = np.dot(X.T,X)
+        XTy = np.dot(X.T,y)
+        weights = np.linalg.solve(XTX,XTy)
+        return weights
+
+class GradientDescentStrategy(RegressionStrategy):
+    def __init__(self,learning_rate=0.01,iterations=1000):
+        self.lr = learning_rate
+        self.iters = iterations
+
+    def train(self,X,y):
+        m , n = X.shape
+        weights = np.zeros(n)
+
+        for _ in range(self.iters):
+            prediction = np.dot(X,weights)
+            errors = prediction - y
+
+            gradient = (1 / m) * np.dot(X.T,errors)
+
+            weights -= self.lr * gradient
+
+        return weights
+
+class DistanceMetric(ABC):
+    @abstractmethod
+    def calculate(self,v1,v2):
+        pass
+
+class EuclideanDistance(DistanceMetric):
+    def calculate(self,v1,v2):
+        def recursive_sum_sq(a, b, idx):
+            if idx == len(a):
+                return 0
+            return (a[idx] - b[idx]) ** 2 + recursive_sum_sq(a, b, idx + 1)
+
+        return np.sqrt(recursive_sum_sq(v1, v2, 0))
+
+class ManhattanDistance(DistanceMetric):
+    def calculate(self,v1,v2):
+        return np.sum(np.abs(v1-v2))
+
+class LinearRegression(BaseAlgorithm):
+    def __init__(self,strategy : RegressionStrategy = LeastSquaresStrategy()):
+        super().__init__()
+        self.strategy = strategy
+        self.weights = None
+
+    def fit(self,X,y):
+        if dimension_control(X,y):
+            X_b = np.c_[np.ones((X.shape[0], 1)), X]
+            self.weights = self.strategy.train(X_b, y)
+
+
+    def predict(self,X):
+        X_b = np.c_[np.ones((X.shape[0], 1)), X]
+        return np.dot(X_b,self.weights)
+
+class KNNClassifier(BaseAlgorithm):
+    def __init__(self,k=3, metric : DistanceMetric = EuclideanDistance()):
+        super().__init__()
+        self.k = k
+        self.metric = metric
+        self.X_train = None
+        self.y_train = None
+
+    def fit(self,X,y):
+        self.X_train = X
+        self.y_train = y
+
+    def _predict_single(self,x_test,results,index):
+        distances = [self.metric.calculate(x_test, x_train) for x_train in self.X_train]
+        k_indices = np.argsort(distances)[:self.k]
+        k_nearest_labels = self.y_train[k_indices]
+
+        counts = np.bincount(k_nearest_labels.astype(int))
+        results[index] = np.argmax(counts)
+
+    def predict(self,X):
+        threads = []
+        predictions = np.zeros(X.shape[0])
+
+        for i,x_test in enumerate(X):
+            t = threading.Thread(target=self._predict_single,args=(x_test,predictions,i))
+            threads.append(t)
+            t.start()
+
+        for t in threads:
+            t.join()
+
+        return predictions
+
+def evaluate_model(y_true,y_pred):
+    errors = (y_true - y_pred) ** 2
+    total_error = reduce(lambda x, y: x + y, errors)
+    return total_error / len(y_true)
+
+
+
+
+
+
+
+
+
+

my_python_lib_tarik-0.1.0/my_python_lib/data.py

@@ -0,0 +1,174 @@
+import pandas as pd
+import numpy as np
+from abc import ABC, abstractmethod
+from typing import List
+from my_python_lib.utils import is_categorical, NotCategoricalError, is_multiple_mode, ColumnNotFoundError
+
+class DataLoader(ABC):
+    @abstractmethod
+    def load(self,source : str) -> pd.DataFrame:
+        pass
+
+class CSVLoader(DataLoader):
+    def load(self,source : str) -> pd.DataFrame:
+        pd.set_option('display.max_columns', None)
+        pd.set_option('display.width', None)
+        return pd.read_csv(source)
+
+class JSONLoader(DataLoader):
+    def load(self,source : str) -> pd.DataFrame:
+        pd.set_option('display.max_columns', None)
+        pd.set_option('display.width', None)
+        return pd.read_json(source)
+
+class DataCreator(ABC):
+    @abstractmethod
+    def create_document(self) -> DataLoader:
+        pass
+
+    def generate_document(self, source : str):
+        document = self.create_document()
+        data = document.load(source)
+        return data
+
+class CSVCreator(DataCreator):
+    def create_document(self) -> DataLoader:
+        return CSVLoader()
+
+class JSONCreator(DataCreator):
+    def create_document(self) -> DataLoader:
+        return JSONLoader()
+
+
+class ImputeStrategy(ABC):
+    @abstractmethod
+    def fill_nulls(self,column : pd.Series) -> pd.Series:
+        pass
+
+class MeanImputer(ImputeStrategy):
+    def fill_nulls(self,column : pd.Series) -> pd.Series:
+        return column.fillna(column.mean())
+
+class MedianImputer(ImputeStrategy):
+    def fill_nulls(self, column : pd.Series) -> pd.Series:
+        return column.fillna(column.median())
+
+class ModeImputer(ImputeStrategy):
+    def fill_nulls(self, column : pd.Series) -> pd.Series:
+        if is_multiple_mode(column):
+            return column.fillna(column.mode().mean())
+        return column.fillna(column.mode())
+
+class UnknownImputer(ImputeStrategy):
+    def fill_nulls(self, column : pd.Series) -> pd.Series:
+        if not is_categorical(column):
+            raise NotCategoricalError(column)
+        return column.astype(str).fillna("Unknown")
+
+
+class EncodingStrategy(ABC):
+    @abstractmethod
+    def encode(self,df : pd.DataFrame, column : str, target : pd.Series = None) -> pd.DataFrame:
+        pass
+
+class LabelEncoder(EncodingStrategy):
+    def encode(self,df : pd.DataFrame, column : str, target : pd.Series = None) -> pd.DataFrame:
+        df_copy = df.copy()
+        df_copy[column] = df_copy[column].astype('category').cat.codes
+        return df_copy
+
+class OneHotEncoder(EncodingStrategy):
+    def encode(self,df : pd.DataFrame, column : str, target : pd.Series = None) -> pd.DataFrame:
+        columns = [column]
+        return pd.get_dummies(df,columns=columns,dtype=int)
+
+
+class TargetEncoder(EncodingStrategy):
+    def encode(self,df : pd.DataFrame, column : str, target : pd.Series = None) -> pd.DataFrame:
+        if target is None:
+            raise ValueError("You need a target column if you want to apply Target Encoder")
+
+        df_copy = df.copy()
+        temp_target_name = '__target_tmp__'
+        df_copy[temp_target_name] = target
+        category_means = df_copy.groupby(column)[temp_target_name].mean()
+        df_copy[column] = df_copy[column].map(category_means)
+        df_copy = df_copy.drop(columns=[temp_target_name])
+        return df_copy
+
+
+class DataProcessor:
+    def __init__(self,data : pd.DataFrame):
+        self._data = data
+
+    @property
+    def data(self) -> pd.DataFrame:
+        return self._data
+
+    def handle_missing_values(self,column : str,strategy : ImputeStrategy):
+        self._data[column] = strategy.fill_nulls(self._data[column])
+
+    def scale_features(self,columns : List[str]):
+        for column in columns:
+            min_value = self._data[column].min()
+            max_value = self._data[column].max()
+            self._data[column] = (self._data[column] - min_value) / (max_value - min_value)
+
+    def transform_categorical(self,column : str, strategy : EncodingStrategy, target_column : str = None):
+        target_series = self._data[target_column] if target_column is not None else None
+        new_df = strategy.encode(self._data,column,target_series)
+
+        self._data._update_inplace(new_df)
+        return self
+
+    def split_features_target(self,target_column : str):
+        X = self._data.drop(columns=[target_column]).values
+        y = self._data[target_column].values
+        return X,y
+
+class DataPipeline:
+    def __init__(self,file_path : str):
+        if file_path.endswith(".csv"):
+            creator = CSVCreator()
+
+        elif file_path.endswith(".json"):
+            creator = JSONCreator()
+
+        else:
+            raise ValueError(f"Invalid file type : {file_path}")
+
+        raw_data = creator.generate_document(file_path)
+        self.processor = DataProcessor(raw_data)
+
+    def run_default_preprocessing(self, target: str, categorical_columns: List[str] = None,encoding_type: str = 'label', imputer : ImputeStrategy = MeanImputer()):
+        if categorical_columns is None:
+            categorical_columns = []
+
+        for col in categorical_columns:
+
+            if col in self.processor.data.columns:
+
+                if encoding_type == 'label':
+                    self.processor.transform_categorical(col, LabelEncoder())
+
+                elif encoding_type == 'onehot':
+                    self.processor.transform_categorical(col, OneHotEncoder())
+                    
+                elif encoding_type == 'target':
+                    self.processor.transform_categorical(col, TargetEncoder(), target_column=target)
+
+            else:
+                raise ColumnNotFoundError(col)
+
+
+        numeric_cols = self.processor.data.select_dtypes(include=[np.number]).columns
+        numeric_features = [col for col in numeric_cols if col != target]
+
+        for col in numeric_features:
+            self.processor.handle_missing_values(col, imputer)
+
+        self.processor.scale_features(numeric_features)
+
+        return self.processor.split_features_target(target)
+
+

my_python_lib_tarik-0.1.0/my_python_lib/utils.py

@@ -0,0 +1,116 @@
+from functools import wraps, reduce
+import pandas as pd
+import numpy as np
+import time
+from typing import Callable, Any
+
+def calculate_missing_values(df : pd.DataFrame):
+    print(" MISSING VALUE CALCULATION")
+    for col in df.columns:
+        missing_num = df[col].isnull().sum()
+        if missing_num > 0:
+            print(f"  --> {col} : {missing_num} missing values")
+
+        else:
+            print(f"  --> {col} : Clean (No missing values)")
+
+def predict_stats(y_predict : np.ndarray):
+    print(f" == [PREDICT DISTRIBUTION STATISTICS] ==")
+    print(f" Min Prediction : {np.min(y_predict):.2f}")
+    print(f" Max Prediction : {np.max(y_predict):.2f}")
+    print(f" Average Prediction : {np.mean(y_predict):.2f}")
+    print(f" Standart Deviation of the Predictions: {np.std(y_predict):.2f}")
+
+def predict_success_summary(y_real : np.ndarray, y_predict : np.ndarray, threshold_error : float):
+    if threshold_error < 0 or threshold_error > 100:
+        raise ValueError("Threshold Value must be between 0 and 100")
+    error_percentages = (np.abs(y_real - y_predict) / y_real) * 100
+    success_predict_num = np.sum(error_percentages < threshold_error)
+    failed_predict_num = np.sum(error_percentages > threshold_error)
+    print(f"Number of Successful Predictions: {success_predict_num}")
+    print(f"Number of Failed Predictions: {failed_predict_num}")
+
+
+def series_to_ndarray(series : pd.Series) -> np.ndarray:
+    clean_list = list(map(lambda x : float(x), series))
+    return np.array(clean_list)
+
+def list_to_ndarray(list : list) -> np.ndarray:
+    return np.array(list)
+
+def dimension_control(X : np.ndarray, y : np.ndarray):
+    if len(X) != len(y):
+        print(f"Error : X row number ({len(X)}) and y row number ({len(y)}) are not equal")
+        return False
+
+    return True
+
+def data_summary(X : np.ndarray):
+    row, column = X.shape
+    print(f"Total Rows : {row}")
+    print(f"Number of Parameters : {column}")
+
+def shuffle_data(X : np.ndarray, y : np.ndarray):
+    random_orders = np.random.permutation(len(X))
+    return X[random_orders], y[random_orders]
+
+def log_operation(func : Callable) -> Callable:
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        print(f"[LOG] {func.__name__} process started")
+        start_time = time.time()
+
+        try:
+            result = func(*args, **kwargs)
+            end_time = time.time()
+            print(f"[LOG] {func.__name__} ended successfully")
+            print(f"Time Taken : {end_time - start_time:.4f}s")
+            return result
+
+        except Exception as e:
+            print(f"[LOG] {func.__name__} failed : {e}")
+            raise e
+
+    return wrapper
+
+def apply_pipeline(data : np.ndarray, transformations : list[Callable]) -> np.ndarray:
+    return reduce(lambda d, func : func(d), transformations, data)
+
+def calculate_accuracy(real, prediction):
+    accuracy = np.mean(real == prediction)
+    print(f"Accuracy rate : %{accuracy * 100:.2f}")
+
+def is_categorical(column : pd.Series) -> bool:
+    if column.dtype in ["object", "category"] or pd.api.types.is_string_dtype(column):
+        return True
+    else:
+        return False
+
+
+class NotCategoricalError(Exception):
+    def __init__(self, column : str):
+        self.column = column
+        super().__init__(f"Column '{column}' is not categorical")
+
+def is_multiple_mode(column : pd.Series) -> bool:
+    if column.mode().shape[0] > 1:
+        return True
+    return False
+
+class ColumnNotFoundError(Exception):
+    def __init__(self, column : str):
+        self.column = column
+        super().__init__(f"Column '{column}' is not found in the data")
+
+def numeric_check(data : pd.DataFrame):
+    index = 0
+    for col in data.columns:
+        if pd.api.types.is_numeric_dtype(data[col]):
+            print(f"--> {col} : Numeric Column")
+        else:
+            print(f"--> {col} : Not Numeric Column")
+            index += 1
+
+    print(f"The Number of Non-Numeric Columns : {index}")
+
+

my_python_lib_tarik-0.1.0/my_python_lib_tarik.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: my_python_lib-tarik
+Version: 0.1.0
+Summary: A modular, object-oriented framework for machine learning and data preprocessing
+Author-email: Mustafa Tarık Kocabıyık <mtarikkb@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=2.4.4
+Requires-Dist: pandas>=3.0.2
+
+# Machine Learning & Data Preprocessing Library
+
+## Introduction
+
+This is a simple machine learning algorithm library consists of Linear Regression , KNN Classifier and some other data processing algorithms from scratch based on numpy and pandas libraries.
+
+---
+
+##  Mapping Core Learning Outcomes
+
+The 6 required patterns were applied appropriately in the project. Every single one is explained below.
+
+### 1. Object-Oriented Programming (OOP)
+- **Where**: In `core.py` and `data.py`.
+- **How**: 
+  - **Inheritance & Abstraction**: Employs abstract base classes (`BaseAlgorithm`, `RegressionStrategy`, `DistanceMetric`, `DataLoader`, `DataCreator`, `ImputeStrategy`, `EncodingStrategy`) to enforce blueprints.
+  - **Polymorphism**: Concrete implementations dynamically substitute base behavior. For example, `LinearRegression` executes `.train()` polymorphic actions via different assigned regression strategies without altering its own structure.
+  - **Encapsulation**: State variables are protected internally. In `data.py`, the raw dataframe is hidden behind a protected attribute `self._data` and managed safely using the `@property` getter.
+
+### 2. Functional Programming
+- **Where**: In `core.py` and `utils.py`.
+- **How**:
+  - **Pure Functions & Lambda**: `evaluate_model` avoids modifying external states and relies entirely on input arguments, calculating mean squared errors via a clean pure lambda routine.
+  - **Higher-Order Functions & Map/Reduce**:
+    - `reduce` combined with `lambda` is used inside `evaluate_model` to sum squared errors.
+    - `map` is used inside `series_to_ndarray` to cast panda series rows to float representations.
+    - `apply_pipeline` utilizes `reduce` to sequentially compose list-based transformation callables across data boundaries (`reduce(lambda d, func: func(d), transformations, data)`).
+
+### 3. Concurrency (Multi-threading)
+- **Where**: Implemented in `core.py` inside the `KNNClassifier` class.
+- **How**: 
+  - Predicting classes for massive feature maps sequentially is computationally bound. The `predict` method generates individual `threading.Thread` operations for every distinct evaluation sample.
+  - The `_predict_single` worker calculates specific row-by-row matrix operations concurrently, storing structural outputs inside a shared pre-allocated numpy results matrix (`results[index]`).
+  - Thread control structures utilize `t.start()` loops followed by systematic `t.join()` barriers to synchronize and block primary execution until parallel estimations conclude safely.
+
+### 4. Recursion / Dynamic Programming
+- **Where**: In `core.py` inside the `EuclideanDistance` class.
+- **How**:
+  - Distance metrics typically resolve dimensions via nested iterative syntax or high-level library functions. This implementation achieves element-wise vector difference accumulations via a custom recursive function `recursive_sum_sq(a, b, idx)`.
+  - It recursively accumulates squared parameter differences index-by-index until it reaches the base case (`idx == len(a)`), gracefully returning the final structural matrix sqrt reduction.
+
+### 5. SOLID Principles
+- **Where**: In `core.py` and `data.py`.
+- **How**:
+  - **Single Responsibility Principle (SRP)**: Classes do exactly one thing. `CSVLoader` only ingests data streams; `MeanImputer` strictly provides missing value fillings; `DataProcessor` focuses on data manipulation.
+  - **Open/Closed Principle (OCP)**: The system is open for extension but closed for modification. Introducing a new distance metric (e.g., Cosine Distance) requires subclassing `DistanceMetric` without touching `KNNClassifier`.
+  - **Liskov Substitution Principle (LSP)**: Derived classes are completely interchangeable with their abstractions. Any encoder (`LabelEncoder`, `OneHotEncoder`, `TargetEncoder`) fulfills the signature constraints expected by `DataProcessor`.
+  - **Interface Segregation Principle (ISP)**: Interfaces remain lean and decoupled. `RegressionStrategy` enforces a single clear contractual point (`train`), avoiding bulky, unrelated structural configurations.
+  - **Dependency Inversion Principle (DIP)**: High-level objects depend on abstractions rather than low-level concrete modules. `LinearRegression` binds entirely against the `RegressionStrategy` interface, decoupling model training mechanisms from specific analytical algorithms.
+
+### 6. Architectural & Design Patterns
+- **Where**: Full design of `data.py` and `core.py`.
+- **How**:
+  - **Pipeline Architecture**: Managed by `DataPipeline` which neatly bridges file checking, concrete factory creation, loading, and structured feature preparation routines into a uniform linear API stream (`run_default_preprocessing`).
+  - **Strategy Pattern**: Implemented multiple times to provide interchangeable components:
+    - Optimization algorithms in `LinearRegression` via `LeastSquaresStrategy` and `GradientDescentStrategy`.
+    - Distance formulations in `KNNClassifier` via `EuclideanDistance` and `ManhattanDistance`.
+    - Data imputation in `DataProcessor` via `MeanImputer`, `MedianImputer`, and `ModeImputer`.
+    - Variable transformations via `LabelEncoder`, `OneHotEncoder`, and `TargetEncoder`.
+  - **Factory Method Pattern**: Used to create appropriate data loaders without binding to concrete files. `DataCreator` acts as the creator interface, declaring `create_document()`. Concrete implementations `CSVCreator` and `JSONCreator` override this method to instantiate and return `CSVLoader` or `JSONLoader` respectively, abstracting the instantiation process away from the main pipeline.

my_python_lib_tarik-0.1.0/my_python_lib_tarik.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+my_python_lib/__init__.py
+my_python_lib/core.py
+my_python_lib/data.py
+my_python_lib/utils.py
+my_python_lib_tarik.egg-info/PKG-INFO
+my_python_lib_tarik.egg-info/SOURCES.txt
+my_python_lib_tarik.egg-info/dependency_links.txt
+my_python_lib_tarik.egg-info/requires.txt
+my_python_lib_tarik.egg-info/top_level.txt
+tests/test1.py
+tests/test2.py

my_python_lib_tarik-0.1.0/my_python_lib_tarik.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

my_python_lib_tarik-0.1.0/my_python_lib_tarik.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy>=2.4.4
+pandas>=3.0.2

my_python_lib_tarik-0.1.0/my_python_lib_tarik.egg-info/top_level.txt

@@ -0,0 +1 @@
+my_python_lib

my_python_lib_tarik-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "my_python_lib-tarik"
+version = "0.1.0"
+description = "A modular, object-oriented framework for machine learning and data preprocessing"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Mustafa Tarık Kocabıyık", email = "mtarikkb@gmail.com"}
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "numpy>=2.4.4",
+    "pandas>=3.0.2"
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["my_python_lib", "core", "data", "utils"]

my_python_lib_tarik-0.1.0/setup.cfg

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

my_python_lib_tarik-0.1.0/tests/test1.py

@@ -0,0 +1,58 @@
+from my_python_lib import CSVCreator, LabelEncoder, TargetEncoder, OneHotEncoder, MeanImputer, ModeImputer, \
+    MedianImputer, UnknownImputer
+from my_python_lib.data import DataPipeline, DataProcessor
+from my_python_lib.utils import calculate_missing_values, is_multiple_mode, numeric_check
+import pandas as pd
+
+# DATA PROCESSING PART
+
+def run():
+    # 1) Creating and Loading Data
+    creator = CSVCreator()
+    data = creator.generate_document("synthetic_dataset.csv")
+    print("1) ===== PURE DATASET =====")
+    print(data.head(20))
+
+    # 2) We saw that there are some empty data. Lets see how many for each column.
+    print("\n2) ===== MISSING VALUES FOR EACH COLUMN =====")
+    calculate_missing_values(data)
+
+    # 3) In order to handle this problem, we will use our DataProcessor class
+    processor = DataProcessor(data)
+    processor.handle_missing_values(column="Stock",strategy=UnknownImputer())
+    processor.handle_missing_values(column="Category",strategy=UnknownImputer())
+    numeric_columns = ["Price","Rating","Discount"]
+    for col in numeric_columns:
+        processor.handle_missing_values(column=col,strategy=MeanImputer())
+    print("\n3) ===== NEW FILLED DATASET =====")
+    print(data.head(20))
+
+    # 4) Lets look at the new missing values for each column
+    print("\n4) ===== NEW MISSING VALUES FOR EACH COLUMN =====")
+    calculate_missing_values(data)
+
+    # 5) Once we did the imputing part, we still have categorical columns which need to be transform into numeric columns.
+    categoric_columns = ["Category","Stock"]
+    for col in categoric_columns:
+        processor.transform_categorical(column=col,strategy=TargetEncoder(),target_column="Discount")
+
+    print("\n5) ===== NEW FULLY NUMERICAL DATASET =====")
+    print(data.head(20))
+
+    # 6) Doing a check if we still have non-numeric columns
+    print(f"\n6 ===== NUMERIC CHECK =====")
+    numeric_check(data)
+
+    # 7) We saw that all columns are numeric, the last thing we need to do is scaling all columns with min-max method in order to prepare the data for training
+    processor.scale_features(data.columns)
+
+    print("\n7) ===== NEW SCALED DATASET =====")
+    print(data.head(20))
+
+
+
+
+
+
+if __name__ == "__main__":
+    run()

my_python_lib_tarik-0.1.0/tests/test2.py

@@ -0,0 +1,52 @@
+from my_python_lib import MeanImputer, LeastSquaresStrategy, evaluate_model, GradientDescentStrategy, predict_stats, \
+    predict_success_summary
+from my_python_lib.data import DataPipeline
+from my_python_lib.core import LinearRegression
+
+# APPLYING ML ALGORITHMS PART
+
+def run():
+    # 1) Instead of using everything one by one that we did in test1, we will apply DataPipeline class that handles every feature in DataProcessor
+    pipeline = DataPipeline("Student_Performance.csv")
+    X, y = pipeline.run_default_preprocessing(target="Performance Index",categorical_columns=["Extracurricular Activities"],encoding_type="target",imputer=MeanImputer())
+    print("1-A) ===== FEATURE MATRIX =====")
+    print(X[:20])
+    print("\n1-B) ===== TARGET MATRIX =====")
+    print(y[:20])
+
+    # 2) Because of our dataset is suitable for Linear Regression, lets try it with regression.
+    model = LinearRegression(strategy=GradientDescentStrategy(learning_rate=0.06,iterations=1938))
+    model.fit(X,y)
+    predictions = model.predict(X)
+    print("\n2) ===== GRADIENT DESCENT RESULTS =====")
+    print(f"--> Calculated Weights : {model.weights}")
+    print(f"--> First 20 Predictions : {predictions[:20]}")
+    print(f"--> First 20 Real Values : {y[:20]}")
+    print(f"--> Error with Mean Squared Error : {evaluate_model(y,predictions)}")
+
+    # 3) Trying with Least Squares Strategy
+    model2 = LinearRegression(strategy=LeastSquaresStrategy())
+    model2.fit(X,y)
+    predictions2 = model2.predict(X)
+    print("\n3) ===== LEAST SQUARES RESULTS =====")
+    print(f"--> Calculated Weights : {model2.weights}")
+    print(f"--> First 20 Predictions : {predictions2[:20]}")
+    print(f"--> First 20 Real Values : {y[:20]}")
+    print(f"--> Error with Mean Squared Error : {evaluate_model(y, predictions2)}")
+
+    # 4) Observing Prediction Statistics
+    print("\n4)A ===== PREDICTION STATS FOR GRADIENT DESCENT STRATEGY =====")
+    predict_stats(predictions)
+    print("\n4)B ===== PREDICTION STATS FOR LEAST SQUARES STRATEGY =====")
+    predict_stats(predictions2)
+
+    # 5) Observing successful predictions and failed predictions with a threshold value
+    print("\n5)A ==== PREDICTION SUCCESS STATS FOR GRADIENT DESCENT STRATEGY =====")
+    predict_success_summary(y,predictions,threshold_error=5)
+    print("\n5)B ==== PREDICTION SUCCESS STATS FOR LEAST SQUARES STRATEGY =====")
+    predict_success_summary(y, predictions2, threshold_error=5)
+
+
+
+if __name__ == "__main__":
+    run()