jackofalltrades 0.0.1__tar.gz

jackofalltrades-0.0.1/LICENSE.txt

@@ -0,0 +1,17 @@
+MIT license
+Copyright 2024 Sane Punk
+
+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.

jackofalltrades-0.0.1/MANIFEST.in

@@ -0,0 +1 @@
+include README.txt

jackofalltrades-0.0.1/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.1
+Name: jackofalltrades
+Version: 0.0.1
+Summary: Tired of complex machine learning libraries? Introducing jackofalltrades, a streamlined Python package designed to make machine learning accessible for everyone.
+Home-page: https://github.com/lazy-punk/jackofalltrades
+Author: Sane Punk
+Author-email: Sane Punk <punk00pp@gmail.com>
+License: MIT
+Project-URL: homepage, https://github.com/lazy-punk/jackofalltrades
+Project-URL: Documentation, https://github.com/lazy-punk/jackofalltrades
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Description-Content-Type: text/plain
+License-File: LICENSE.txt
+Requires-Dist: pandas>=2.2.2
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: scikit-learn>=1.5.0
+Requires-Dist: matplotlib>=3.9.0
+Requires-Dist: jax[cpu]>=0.4.28
+Requires-Dist: tqdm>=4.66.4
+
+Jack of All Trades: A Simple and User-Friendly Machine Learning Toolkit
+Tired of complex machine learning libraries? Introducing jackofalltrades, a streamlined Python package designed to make machine learning accessible for everyone. Whether you're a beginner eager to learn the fundamentals, an experienced user seeking a simpler alternative for quick experimentation, or an educator looking for a user-friendly teaching tool, jackofalltrades is here to empower you.
+What sets jackofalltrades apart?
+•	Simplicity: We prioritize clear, concise functions with minimal parameters and intuitive interfaces. No more struggling to decipher complex syntax or documentation.
+•	Ease of Use: Get started quickly with our well-documented functions and a focus on straightforward implementation. You'll be building and evaluating machine learning models in no time.
+•	Core Machine Learning Algorithms: Built-in implementations for essential algorithms like linear regression (and more to come!). Experiment with foundational concepts and solve real-world problems efficiently.
+•	Compatibility: Seamlessly work with data formats used by popular libraries like scikit-learn. Integrate jackofalltrades into your existing machine learning workflows effortlessly.
+Key Features:
+•	Intuitive API: Designed with ease of use in mind, jackofalltrades promotes efficient code writing and rapid learning.
+•	Focus on Core Concepts: Gain a solid understanding of machine learning fundamentals without getting bogged down in advanced complexities.
+•	Lightweight and Efficient: Streamlined implementation ensures minimal overhead for your projects.
+•	Active Development: We're continuously working to expand the library's capabilities and enhance user experience.
+Installation
+Install jackofalltrades using pip:
+# Bash
+```pip install jackofalltrades```
+Usage Example (Linear Regression)
+Here's a quick example demonstrating how to use jackofalltrades for linear regression:
+# Python
+```import jackofalltrades as joft
+from jackofalltrades.datasets import get_data
+
+# Load data and split into training and testing sets
+ldset = get_dataset()
+X, y = ldset.get_btc()
+
+# Train a linear regression model
+model = joft.Models.LinearRegression(X, y)
+model.fit()
+
+# Make predictions and evaluate performance
+y_predicted = model.predict(X)
+model.evaluate(y, y_predicted)```
+For more in-depth explanations, advanced usage examples, and API documentation, please refer to the detailed documentation (coming soon).
+Contributing
+We welcome contributions to jackofalltrades! If you'd like to get involved, please refer to the contribution guidelines (coming soon).
+License
+This project is licensed under the MIT License. See the LICENSE file for details.
+

jackofalltrades-0.0.1/README.txt

@@ -0,0 +1,39 @@
+Jack of All Trades: A Simple and User-Friendly Machine Learning Toolkit
+Tired of complex machine learning libraries? Introducing jackofalltrades, a streamlined Python package designed to make machine learning accessible for everyone. Whether you're a beginner eager to learn the fundamentals, an experienced user seeking a simpler alternative for quick experimentation, or an educator looking for a user-friendly teaching tool, jackofalltrades is here to empower you.
+What sets jackofalltrades apart?
+•	Simplicity: We prioritize clear, concise functions with minimal parameters and intuitive interfaces. No more struggling to decipher complex syntax or documentation.
+•	Ease of Use: Get started quickly with our well-documented functions and a focus on straightforward implementation. You'll be building and evaluating machine learning models in no time.
+•	Core Machine Learning Algorithms: Built-in implementations for essential algorithms like linear regression (and more to come!). Experiment with foundational concepts and solve real-world problems efficiently.
+•	Compatibility: Seamlessly work with data formats used by popular libraries like scikit-learn. Integrate jackofalltrades into your existing machine learning workflows effortlessly.
+Key Features:
+•	Intuitive API: Designed with ease of use in mind, jackofalltrades promotes efficient code writing and rapid learning.
+•	Focus on Core Concepts: Gain a solid understanding of machine learning fundamentals without getting bogged down in advanced complexities.
+•	Lightweight and Efficient: Streamlined implementation ensures minimal overhead for your projects.
+•	Active Development: We're continuously working to expand the library's capabilities and enhance user experience.
+Installation
+Install jackofalltrades using pip:
+# Bash
+```pip install jackofalltrades```
+Usage Example (Linear Regression)
+Here's a quick example demonstrating how to use jackofalltrades for linear regression:
+# Python
+```import jackofalltrades as joft
+from jackofalltrades.datasets import get_data
+
+# Load data and split into training and testing sets
+ldset = get_dataset()
+X, y = ldset.get_btc()
+
+# Train a linear regression model
+model = joft.Models.LinearRegression(X, y)
+model.fit()
+
+# Make predictions and evaluate performance
+y_predicted = model.predict(X)
+model.evaluate(y, y_predicted)```
+For more in-depth explanations, advanced usage examples, and API documentation, please refer to the detailed documentation (coming soon).
+Contributing
+We welcome contributions to jackofalltrades! If you'd like to get involved, please refer to the contribution guidelines (coming soon).
+License
+This project is licensed under the MIT License. See the LICENSE file for details.
+

jackofalltrades-0.0.1/jackofalltrades/Errors/__init__.py

@@ -0,0 +1 @@
+from .error import Error

jackofalltrades-0.0.1/jackofalltrades/Errors/error.py

@@ -0,0 +1,195 @@
+import jax.numpy as np
+from sklearn.metrics import confusion_matrix
+
+class Error:
+      """
+      Class to calculate various error metrics for regression and classification tasks.
+      """
+
+      def __init__(self, y_true, y_predicted) -> None:
+            """
+            Initialize the Error class with true and predicted values.
+
+            Args:
+                  y_true (array-like): True values.
+                  y_predicted (array-like): Predicted values.
+            """
+            try:
+                  self.y_true, self.y_predicted = np.array(y_true, dtype=np.float32), np.array(y_predicted, dtype=np.float32)
+            except Exception as e:
+                  raise Exception(f"Error: {e}")
+            
+      def MSE(self) -> np.float32:
+            """
+            Calculate the Mean Squared Error (MSE).
+
+            Returns:
+                  np.float32: The calculated MSE value.
+            """
+            try:
+                  return np.mean(np.square((self.y_true - self.y_predicted)))
+            except Exception as e:
+                  raise Exception(f"Error: {e}")
+  
+      def RMSE(self) -> np.float32:
+            """
+            Calculate the Root Mean Squared Error (RMSE).
+
+            Returns:
+                  np.float32: The calculated RMSE value.
+            """
+            try:
+                  return np.sqrt(np.mean(np.square((self.y_true - self.y_predicted))))
+            except Exception as e:
+                  raise Exception(f"Error: {e}")
+  
+      def MAE(self) -> np.float32:
+            """
+            Calculate the Mean Absolute Error (MAE).
+
+            Returns:
+                  np.float32: The calculated MAE value.
+            """
+            try:
+                  return np.mean(np.abs((self.y_true - self.y_predicted)))
+            except Exception as e:
+                  raise Exception(f"Error: {e}")
+  
+      def SOAE(self) -> np.float32:
+            """
+            Calculate the Sum of Absolute Errors (SOAE).
+
+            Returns:
+                  np.float32: The calculated SOAE value.
+            """
+            try:
+                  return np.abs(np.sum(self.y_true - self.y_predicted))
+            except Exception as e:
+                  raise Exception(f"Error: {e}")
+  
+      def SOE(self) -> np.float32:
+            """
+            Calculate the Sum of Errors (SOE).
+
+            Returns:
+                  np.float32: The calculated SOE value.
+            """
+            try:
+                  return np.sum(self.y_true - self.y_predicted)
+            except Exception as e:
+                  raise Exception(f"Error: {e}")
+  
+      def RSquared(self) -> np.float32:
+            """
+            Calculate the R-squared value.
+
+            Returns:
+                  np.float32: The calculated R-squared value.
+            """
+            try:
+                  return 1 - (np.sum(np.square(self.y_true - self.y_predicted)) / np.sum(np.square(self.y_true - np.mean(self.y_true))))
+            except Exception as e:
+                  raise Exception(f"Error: {e}")
+  
+      def MAPE(self) -> np.float32:
+            """
+            Calculate the Mean Absolute Percentage Error (MAPE).
+
+            Returns:
+                  np.float32: The calculated MAPE value.
+            """
+            try:
+                  return np.mean(np.abs((self.y_true - self.y_predicted) / self.y_true)) * 100
+            except Exception as e:
+                  raise Exception(f"Error: {e}")
+  
+      def AdjustedRSquared(self, n, p) -> np.float32:
+            """
+            Calculate the Adjusted R-squared value.
+
+            Args:
+                  n (int): Number of observations.
+                  p (int): Number of predictors.
+
+            Returns:
+                  np.float32: The calculated Adjusted R-squared value.
+            """
+            try:
+                  return 1 - ((1 - self.RSquared()) * (n - 1) / (n - p - 1))
+            except Exception as e:
+                  raise Exception(f"Error: {e}")
+  
+      def Accuracy(self) -> np.float32:
+            """
+            Calculate the Accuracy.
+
+            Returns:
+                  np.float32: The calculated Accuracy value.
+            """
+            try:
+                  cm = confusion_matrix(self.y_true, self.y_predicted)
+                  TN, FP, FN, TP = cm.ravel()
+                  return (TP + TN) / (TP + TN + FP + FN)
+            except Exception as e:
+                  raise Exception(f"Error: {e}")
+  
+      def Precision(self) -> np.float32:
+            """
+            Calculate the Precision.
+
+            Returns:
+                  np.float32: The calculated Precision value.
+            """
+            try:
+                  cm = confusion_matrix(self.y_true, self.y_predicted)
+                  TN, FP, FN, TP = cm.ravel()
+                  return TP / (TP + FP)
+            except Exception as e:
+                  raise Exception(f"Error: {e}")
+  
+      def Recall(self) -> np.float32:
+            """
+            Calculate the Recall.
+
+            Returns:
+                  np.float32: The calculated Recall value.
+            """
+            try:
+                  cm = confusion_matrix(self.y_true, self.y_predicted)
+                  TN, FP, FN, TP = cm.ravel()
+                  return TP / (TP + FN) 
+            except Exception as e:
+                  raise Exception(f"Error: {e}")  
+  
+      def F1Score(self) -> np.float32:
+            """
+            Calculate the F1 Score.
+
+            Returns:
+                  np.float32: The calculated F1 Score value.
+            """
+            try:
+                  cm = confusion_matrix(self.y_true, self.y_predicted)
+                  TN, FP, FN, TP = cm.ravel()
+                  return 2 * TP / (2 * TP + FP + FN)
+            except Exception as e:
+                  raise Exception(f"Error: {e}")
+  
+      def Cross_Entropy(self) -> np.float32:
+            """
+            Calculate the Cross Entropy.
+
+            Returns:
+                  np.float32: The calculated Cross Entropy value.
+            """
+            try:
+                  return (1 - self.y_true) * np.log(1 - self.y_predicted) + self.y_true * np.log(self.y_predicted)
+            except Exception as e:  # Use the actual exception object 'e'
+                  # Consider a more informative error message or handling strategy
+                  print(f"Error during Cross Entropy calculation: {e}")
+                  return np.nan  # Or a more appropriate default value
+
+            
+      
+
+            

jackofalltrades-0.0.1/jackofalltrades/Models/Regression.py

@@ -0,0 +1,198 @@
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from matplotlib import pyplot as plt
+from tqdm import tqdm as tqdm
+from sklearn.preprocessing import StandardScaler
+
+import sklearn.metrics as metrics
+
+# Class for implementing Linear Regression
+class LinearRegression:
+      def __init__(self, learning_rate : float = 0.03, epochs : int = 10000, regularization_strength: float = 0.1, data_regularization = True) -> None:
+            """
+            Initialize the LinearRegression object.
+
+            Parameters:
+            - learning_rate: Learning rate for gradient descent (default = 0.03).
+            - epochs: Number of training iterations (default = 10000).
+            - regularization_strength (default = 0.1)
+            """
+            try:
+                  self.data_regularization = data_regularization
+                  self.regularization_strength = regularization_strength
+                  self.learning_rate = learning_rate
+                  self.epochs = epochs
+            except Exception as e:
+                  print("An error occurred during initialization:", str(e))
+      
+      def Standard(self, X):
+            SS = StandardScaler()
+            g = SS.fit(X)
+            g = SS.transform(X)
+            return g
+      
+      def fit(self, X: pd.DataFrame , y: pd.Series) -> None:
+            """
+            Train the linear regression model using gradient descent.
+            Parameters:
+            - X: Input features as a pandas DataFrame.
+            - y: Target variable as a pandas Series.
+            """
+            try:
+                  self.X, self.y = np.array(X, dtype= np.float32), np.array(y, dtype = np.float32)
+                  if self.data_regularization == True:
+                        self.X = self.Standard(self.X)
+                  self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(self.X, self.y, test_size=0.01, random_state=42)
+                  self.m, self.n = self.X_train.shape
+                  self.w = np.random.normal(size=self.n)
+                  self.b = 0
+                  y_pred = np.dot(self.X_train, self.w) + self.b
+                  self.cost = []
+                  self.epoch = []
+                  description = tqdm(range(self.epochs))
+                  for i in description:
+                        y_pred = np.dot(self.X_train, self.w) + self.b
+                        dw = (1/self.m) * np.dot(self.X_train.T, (y_pred - self.y_train)) + (2 * self.regularization_strength / self.m) * self.w
+                        db = (1/self.m) * np.sum(y_pred - self.y_train)
+                        self.w -= self.learning_rate * dw
+                        self.b -= self.learning_rate * db
+                        self.cost.append(np.mean(np.square(y_pred - self.y_train)))
+                        self.epoch.append(i)
+                        description.set_description(f"Cost: {self.cost[-1]}")
+                        
+
+            except Exception as e:
+                  print("An error occurred during fitting:", str(e))
+
+      def predict(self, X_test: pd.DataFrame) -> np.ndarray:
+            """
+            Predict the target variable for the given input features.
+
+            Parameters:
+            - X_test: Input features for prediction as a pandas DataFrame.
+
+            Returns:
+            - Predicted target variable as a numpy array.
+            """
+            if self.data_regularization == True:
+                  X_test = self.Standard(X_test)
+            return np.dot(np.array(X_test, dtype = np.float32), self.w) + self.b
+
+      def plot_cost(self) -> None:
+            """
+            Plot the cost function over training iterations.
+            """
+            plt.plot(self.cost ,self.epoch)
+            plt.show()
+
+      def evaluate(self, y_true : np.ndarray, y_pred : np.ndarray) -> None:
+            """
+            Evaluate the model using the R-squared metric.
+
+            Parameters:
+            - X_test: Test input features as a numpy array.
+            - y_test: Test target variable as a numpy array.
+            """
+            print(metrics.r2_score(y_true, y_pred))
+
+class LogisticRegression:
+
+      def __init__(self, learning_rate : float = 0.03, epochs : int = 10000, regularization_strength: float = 0.1, data_regularization = True) -> None:
+            """
+            Initialize the LogisticRegression object.
+
+            Parameters:
+            - learning_rate: Learning rate for gradient descent (default = 0.03).
+            - epochs: Number of training iterations (default = 10000).
+            - regularization_strength (default = 0.1)
+            """
+            try:
+                  self.data_regularization = data_regularization
+                  self.regularization_strength = regularization_strength
+                  self.learning_rate = learning_rate
+                  self.epochs = epochs
+            except Exception as e:
+                  print("An error occurred during initialization:", str(e))   
+
+      def Standard(self, X):
+            SS = StandardScaler()
+            g = SS.fit(X)
+            g = SS.transform(X)
+            return g
+      
+      def sigmoid(self, z: np.ndarray) -> np.ndarray:
+            """
+            Calculate the sigmoid function.
+
+            Parameters:
+            - z: Input value.
+
+            Returns:
+            - Sigmoid value.
+            """
+            return 1 / (1 + np.exp(-z))
+      
+      def fit(self,  X: pd.DataFrame , y: pd.Series) -> None:
+            """   
+            Train the logistic regression model using gradient descent.
+            Parameters:
+            - X: Input features as a pandas DataFrame.
+            - y: Target variable as a pandas Series.
+            """
+            try:
+                  self.X, self.y = np.array(X, dtype= np.float32), np.array(y, dtype = np.float32)
+                  if self.data_regularization == True:
+                        self.X = self.Standard(self.X)
+                  self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(self.X / np.max(self.X), self.y, test_size=0.01, random_state=42)
+                  self.m, self.n = self.X_train.shape
+                  self.w = np.zeros(self.n)
+                  self.b = 0
+                  y_pred = self.sigmoid(np.dot(self.X_train, self.w) + self.b)
+                  self.cost = []
+                  self.epoch = []
+                  description = tqdm(range(self.epochs))
+                  for i in description:
+                        y_pred = self.sigmoid(np.dot(self.X_train, self.w) + self.b)
+                        loss = -1/self.m * np.sum(self.y_train * np.log(y_pred) + (1 - self.y_train) * np.log(1 - y_pred))
+                        dw = (1/self.m) * np.dot(self.X_train.T, (y_pred - self.y_train)) + (2 * self.regularization_strength / self.m) * self.w
+                        db = (1/self.m) * np.sum(y_pred - self.y_train)
+                        self.w -= self.learning_rate * dw
+                        self.b -= self.learning_rate * db
+                        self.cost.append(loss)
+                        self.epoch.append(i)
+                        description.set_description(f"Cost: {self.cost[-1]}")
+
+            except Exception as e:
+                  print("An error occurred during fitting:", str(e))
+
+      def predict(self, X_test: pd.DataFrame) -> np.ndarray:
+            """
+            Predict the target variable for the given input features.
+
+            Parameters:
+            - X_test: Input features for prediction as a pandas DataFrame.
+
+            Returns:
+            - Predicted target variable as a numpy array.
+            """
+            if self.data_regularization == True:
+                  X_test = self.Standard(X_test)
+            return (self.sigmoid(np.dot(np.array(X_test , dtype = np.float32) / np.max(self.X), self.w) + self.b) > 0.5).astype(int)
+
+      def plot_cost(self) -> None:
+            """
+            Plot the cost function over training iterations.
+            """
+            plt.plot(self.cost ,self.epoch)
+            plt.show()
+
+      def evaluate(self, y_true : np.ndarray, y_predicted : np.ndarray) -> None:
+            """
+            Evaluate the model using the R-squared metric.
+
+            Parameters:
+            - X_test: Test input features as a numpy array.
+            - y_test: Test target variable as a numpy array.
+            """
+            print(metrics.accuracy_score(y_true, (y_predicted > 0.5).astype(int)))

jackofalltrades-0.0.1/jackofalltrades/Models/__init__.py

@@ -0,0 +1 @@
+from .Regression import LinearRegression, LogisticRegression