quicklearnkit 0.0.1__py3-none-any.whl

quicklearn/__init__.py

@@ -0,0 +1,2 @@
+from .quickimports import *
+from .utils import create_random

quicklearn/classifier.py

@@ -0,0 +1,90 @@
+from sklearn.linear_model import LogisticRegression as logisticregression
+from sklearn.neighbors import KNeighborsClassifier as knnclassifier
+from sklearn.tree import DecisionTreeClassifier as decisiontreeclassifier
+from sklearn.ensemble import RandomForestClassifier as randomforestclassifier
+from sklearn.ensemble import GradientBoostingClassifier as gradientboostingclassifier
+from sklearn.ensemble import AdaBoostClassifier as adaboostclassifier
+from xgboost import XGBClassifier as xgboostclassifier
+from sklearn.svm import SVC as supportvectorclassifer
+
+
+class LogisticRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = logisticregression(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+
+class KNeighborsClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = knnclassifier(**kwargs)
+
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+class DecisionTreeClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = decisiontreeclassifier(**kwargs)
+    
+    def fit(self,X,y):
+        self.model.fit(X,y)
+
+    def predict(self, X):
+        self.model.predict(X)
+
+class RandomForestClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = randomforestclassifier(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class GradientBoostingClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = gradientboostingclassifier(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class AdaBoostClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = adaboostclassifier(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class SVClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = supportvectorclassifer(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class XGBClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = xgboostclassifier(**kwargs)
+
+    def fit (self, X,y):
+        self.model.fit(X,y)
+
+    def predict(self, X):
+        self.model.fit(X)

quicklearn/quickimports.py

@@ -0,0 +1,21 @@
+#from .regression import LinearRegression, KNeighborsRegression, DecisionTreeRegression, RandomForestRegression, AdaBoostRegression, GradientBoostingRegression, XGBRegressor,SVR
+#from .classifier import LogisticRegression, KNeighborsClassifier, DecisionTreeClassifier, RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, XGBClassifier, SVC
+
+#__all__= [
+#    'LinearRegression', ' KNeighborsRegressor', 'DecisionTreeRegressor', 'RandomForestRegressor', 'AdaBoostRegressor', 'GradientBoostingRegressor', 'XGBRegressor', 'SVR',
+#    'LogisticRegression', 'KNeighborsClassifier', 'DecisionTreeClassifier', 'RandomForestClassifier', 'AdaBoostClassifier', 'GradientBoostingClassifier', 'XGBClassifier', 'SVC'
+#]
+
+from .regressor import LinearRegressionmodel, KNNRegressionmodel, DecisionTreeRegressionmodel, RandomForestRegressionmodel, GradientBoostingRegressionmodel, AdaBoostRegressionmodel, XGBoostRegressionmodel, ElasticNetRegressionmodel
+from .classifier import LogisticRegressionmodel, KNeighborsClassifiermodel, DecisionTreeClassifiermodel, RandomForestClassifiermodel, AdaBoostClassifiermodel, GradientBoostingClassifiermodel, XGBClassifiermodel, SVClassifiermodel
+from .utils import create_random
+
+__all__=[
+    'LinearRegressionmodel','LogisticRegressionmodel', 'KNNRegressionmodel','GradientBoostingRegressionmodel',
+    'AdaBoostRegressionmodel', 'XGBoostRegressionmodel', 'ElasticNetRegressionmodel',
+    'DecisionTreeRegressionmodel', 'RandomForestRegressionmodel',
+    'KNeighborsClassifiermodel', 'DecisionTreeClassifiermodel', 'RandomForestClassifiermodel','AdaBoostClassifiermodel', 
+    'GradientBoostingClassifiermodel', 'XGBClassifiermodel', 'SVClassifiermodel',
+    'create_random'
+]
+

quicklearn/regressor.py

@@ -0,0 +1,92 @@
+from sklearn.linear_model import LinearRegression as linearregression
+from sklearn.neighbors import KNeighborsRegressor as knnregressor
+from sklearn.tree import DecisionTreeRegressor as decisiontreeregressor
+from sklearn.ensemble import RandomForestRegressor as randomforestregressor
+from sklearn.ensemble import GradientBoostingRegressor as gradientboostingregressor
+from sklearn.ensemble import AdaBoostRegressor as adaboostregressor
+from xgboost import XGBRegressor as xgboostregressor
+from sklearn.svm import SVR as supportvectorregressor
+from sklearn.linear_model import ElasticNet as elasticnetregressor
+
+
+
+class LinearRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = linearregression(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+
+class KNNRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = knnregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class DecisionTreeRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = decisiontreeregressor(**kwargs)
+    
+    def fit(self,X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class RandomForestRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = randomforestregressor(**kwargs)
+
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+class GradientBoostingRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = randomforestregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+    
+class AdaBoostRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = adaboostregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+class XGBoostRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = xgboostregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+class ElasticNetRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = elasticnetregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)

quicklearn/utils.py

@@ -0,0 +1,39 @@
+import numpy as np
+
+def create_random(mean, std, size, random_state=None):
+    """
+    Generate random data with a specified mean and standard deviation.
+
+    Parameters:
+        mean (float): Desired mean of the data.
+        std (float): Desired standard deviation of the data.
+        size (int): Length of the data to generate.
+        random_state (int, optional): Seed for reproducibility. Defaults to None.
+
+    Returns:
+        dict: A dictionary containing:
+            - "data": Random data with the specified mean and standard deviation.
+            - "mean": Actual mean of the generated data.
+            - "std": Actual standard deviation of the generated data.
+
+    Raises:
+        ValueError: If std is negative or size is not a positive integer.
+    """
+    if std < 0:
+        raise ValueError("Standard deviation must be non-negative.")
+    if size <= 0:
+        raise ValueError("Size must be a positive integer.")
+
+    # Create a random number generator instance
+    rng = np.random.default_rng(random_state)
+    
+    # Generate random normal data
+    x = rng.normal(size=size)
+    x1 = (x - np.mean(x)) / np.std(x)
+    x2 = (x1 * std) + mean
+
+    return {
+        "data": x2,
+        "mean": np.mean(x2),
+        "std": np.std(x2)
+    }

quicklearnkit/__init__.py

@@ -0,0 +1,2 @@
+from .quickimports import *
+from .utils import create_random

quicklearnkit/classifier.py

@@ -0,0 +1,90 @@
+from sklearn.linear_model import LogisticRegression as logisticregression
+from sklearn.neighbors import KNeighborsClassifier as knnclassifier
+from sklearn.tree import DecisionTreeClassifier as decisiontreeclassifier
+from sklearn.ensemble import RandomForestClassifier as randomforestclassifier
+from sklearn.ensemble import GradientBoostingClassifier as gradientboostingclassifier
+from sklearn.ensemble import AdaBoostClassifier as adaboostclassifier
+from xgboost import XGBClassifier as xgboostclassifier
+from sklearn.svm import SVC as supportvectorclassifer
+
+
+class LogisticRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = logisticregression(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+
+class KNeighborsClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = knnclassifier(**kwargs)
+
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+class DecisionTreeClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = decisiontreeclassifier(**kwargs)
+    
+    def fit(self,X,y):
+        self.model.fit(X,y)
+
+    def predict(self, X):
+        self.model.predict(X)
+
+class RandomForestClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = randomforestclassifier(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class GradientBoostingClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = gradientboostingclassifier(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class AdaBoostClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = adaboostclassifier(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class SVClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = supportvectorclassifer(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class XGBClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = xgboostclassifier(**kwargs)
+
+    def fit (self, X,y):
+        self.model.fit(X,y)
+
+    def predict(self, X):
+        self.model.fit(X)

quicklearnkit/quickimports.py

@@ -0,0 +1,21 @@
+#from .regression import LinearRegression, KNeighborsRegression, DecisionTreeRegression, RandomForestRegression, AdaBoostRegression, GradientBoostingRegression, XGBRegressor,SVR
+#from .classifier import LogisticRegression, KNeighborsClassifier, DecisionTreeClassifier, RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, XGBClassifier, SVC
+
+#__all__= [
+#    'LinearRegression', ' KNeighborsRegressor', 'DecisionTreeRegressor', 'RandomForestRegressor', 'AdaBoostRegressor', 'GradientBoostingRegressor', 'XGBRegressor', 'SVR',
+#    'LogisticRegression', 'KNeighborsClassifier', 'DecisionTreeClassifier', 'RandomForestClassifier', 'AdaBoostClassifier', 'GradientBoostingClassifier', 'XGBClassifier', 'SVC'
+#]
+
+from .regressor import LinearRegressionmodel, KNNRegressionmodel, DecisionTreeRegressionmodel, RandomForestRegressionmodel, GradientBoostingRegressionmodel, AdaBoostRegressionmodel, XGBoostRegressionmodel, ElasticNetRegressionmodel
+from .classifier import LogisticRegressionmodel, KNeighborsClassifiermodel, DecisionTreeClassifiermodel, RandomForestClassifiermodel, AdaBoostClassifiermodel, GradientBoostingClassifiermodel, XGBClassifiermodel, SVClassifiermodel
+from .utils import create_random
+
+__all__=[
+    'LinearRegressionmodel','LogisticRegressionmodel', 'KNNRegressionmodel','GradientBoostingRegressionmodel',
+    'AdaBoostRegressionmodel', 'XGBoostRegressionmodel', 'ElasticNetRegressionmodel',
+    'DecisionTreeRegressionmodel', 'RandomForestRegressionmodel',
+    'KNeighborsClassifiermodel', 'DecisionTreeClassifiermodel', 'RandomForestClassifiermodel','AdaBoostClassifiermodel', 
+    'GradientBoostingClassifiermodel', 'XGBClassifiermodel', 'SVClassifiermodel',
+    'create_random'
+]
+

quicklearnkit/regressor.py

@@ -0,0 +1,92 @@
+from sklearn.linear_model import LinearRegression as linearregression
+from sklearn.neighbors import KNeighborsRegressor as knnregressor
+from sklearn.tree import DecisionTreeRegressor as decisiontreeregressor
+from sklearn.ensemble import RandomForestRegressor as randomforestregressor
+from sklearn.ensemble import GradientBoostingRegressor as gradientboostingregressor
+from sklearn.ensemble import AdaBoostRegressor as adaboostregressor
+from xgboost import XGBRegressor as xgboostregressor
+from sklearn.svm import SVR as supportvectorregressor
+from sklearn.linear_model import ElasticNet as elasticnetregressor
+
+
+
+class LinearRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = linearregression(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+
+class KNNRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = knnregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class DecisionTreeRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = decisiontreeregressor(**kwargs)
+    
+    def fit(self,X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class RandomForestRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = randomforestregressor(**kwargs)
+
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+class GradientBoostingRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = randomforestregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+    
+class AdaBoostRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = adaboostregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+class XGBoostRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = xgboostregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+class ElasticNetRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = elasticnetregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)

quicklearnkit/utils.py

@@ -0,0 +1,39 @@
+import numpy as np
+
+def create_random(mean, std, size, random_state=None):
+    """
+    Generate random data with a specified mean and standard deviation.
+
+    Parameters:
+        mean (float): Desired mean of the data.
+        std (float): Desired standard deviation of the data.
+        size (int): Length of the data to generate.
+        random_state (int, optional): Seed for reproducibility. Defaults to None.
+
+    Returns:
+        dict: A dictionary containing:
+            - "data": Random data with the specified mean and standard deviation.
+            - "mean": Actual mean of the generated data.
+            - "std": Actual standard deviation of the generated data.
+
+    Raises:
+        ValueError: If std is negative or size is not a positive integer.
+    """
+    if std < 0:
+        raise ValueError("Standard deviation must be non-negative.")
+    if size <= 0:
+        raise ValueError("Size must be a positive integer.")
+
+    # Create a random number generator instance
+    rng = np.random.default_rng(random_state)
+    
+    # Generate random normal data
+    x = rng.normal(size=size)
+    x1 = (x - np.mean(x)) / np.std(x)
+    x2 = (x1 * std) + mean
+
+    return {
+        "data": x2,
+        "mean": np.mean(x2),
+        "std": np.std(x2)
+    }

quicklearnkit-0.0.1.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: quicklearnkit
+Version: 0.0.1
+Summary: A simplified interface for machine learning algorithms.
+Home-page: https://github.com/yourusername/quicklearn
+Author: hazi
+Author-email: hajiafribaba@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: scikit-learn
+Requires-Dist: pandas
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+This is an upcoming wrapper library for machine learning beginners and all the enthusisasts out there who want to reduce the time taken for projects, this library works on simple principle and it is gonna save lot of time in upcoming future 

quicklearnkit-0.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+quicklearn/__init__.py,sha256=JyJhQb2M_RMI4_BtlFhPCWP5OYUCFaU7fNND80ILL7c,61
+quicklearn/classifier.py,sha256=N4gDsxLbzZr8YWNPbwF3OIBVNRi8wmBn1VOPOfwc0ZM,2520
+quicklearn/quickimports.py,sha256=uvzVaZb_rL_M8Za3ThIjZRItny6b8GFa-B9ZCB0l3o0,1744
+quicklearn/regressor.py,sha256=IGwzmjOgyE8dggKg4E6tBJHVqycrHem_fKs4iaN5wmY,2583
+quicklearn/utils.py,sha256=HUjAnphhXOQCRGzk8uyLXmRvDJVk4qSsSK10gUhAuO8,1298
+quicklearnkit/__init__.py,sha256=JyJhQb2M_RMI4_BtlFhPCWP5OYUCFaU7fNND80ILL7c,61
+quicklearnkit/classifier.py,sha256=N4gDsxLbzZr8YWNPbwF3OIBVNRi8wmBn1VOPOfwc0ZM,2520
+quicklearnkit/quickimports.py,sha256=uvzVaZb_rL_M8Za3ThIjZRItny6b8GFa-B9ZCB0l3o0,1744
+quicklearnkit/regressor.py,sha256=IGwzmjOgyE8dggKg4E6tBJHVqycrHem_fKs4iaN5wmY,2583
+quicklearnkit/utils.py,sha256=HUjAnphhXOQCRGzk8uyLXmRvDJVk4qSsSK10gUhAuO8,1298
+quicklearnkit-0.0.1.dist-info/METADATA,sha256=my8HrHPwNzbt0oUYPbMoltOrBQnrOx5S2ZDAlLDaCDg,972
+quicklearnkit-0.0.1.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+quicklearnkit-0.0.1.dist-info/top_level.txt,sha256=ySd2_K8q0dCUBRMpJo-tbYbfabnkGQZpDjbRQpyh9uw,14
+quicklearnkit-0.0.1.dist-info/RECORD,,

quicklearnkit-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.3.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

quicklearnkit-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+quicklearnkit