rslearn-ML 1.0.0__py3-none-any.whl

rslearn/__init__.py

@@ -0,0 +1,3 @@
+from . import linear_model, metrics, preprocessing, model_selection
+
+__all__ = ["linear_model", "metrics", "preprocessing", "model_selection"]

rslearn/linear_model/_LinearRegression.py

@@ -0,0 +1,242 @@
+"""
+Things : - 
+
+# it is linear regression
+y = m1x1 + m1x2 + m3x3 + ... + MnXn + b
+
+y = prediction
+m = weight
+x = value
+b = bias
+
+loss = prediction - real_val
+dw = gradient descent of weight
+db = gradient descenf of bias
+
+It uses Gradients so, Use `StandardScaler` or `MinMaxScaler` for better result  
+
+Scalers...
+>>> from rslearn.preprocessing import StandardScaler, MinMaxScaler
+Read READNE.md or Documentation for More Information about their Functions
+"""
+
+import numpy as np
+from rslearn.metrics import mse
+
+class LinearRegression():
+
+
+    def __init__(self, regulization=None, alpha : float = 0.1, l1_ratio=0.5):
+
+        """
+        Linear Regression
+        ------------------------
+
+        linear Regression for 1D and 2D metrics arrays  using gradient descents and regulization  
+        use Scalers like MinMaxScaler or StandardScaler before fitting for haldle large value  
+
+        Example
+        --------
+        regulization: regulizing option to avoid overfitting  
+            options:  `l1` for Lasso  
+                      `l2` for Ridge  
+                      `elastic_net` for elastic_net
+            
+            Default: None, For No regulization.
+        
+        alpha: alpha value for Ridge, Lasso, ElasticNet  
+            Default: 0.1  
+        
+        l1_ratio: Lasso Ratio for Better ElasticNet Gradient and MSE  
+            Default: 0.5  
+        
+        Functions
+        ---------
+        fit()
+            Function for Train Model | use MinMaxScaler for good Computation and Prediction  
+            Parameters - given in Function
+        
+        get_weight_bias()
+            Returns Selected weight and Bias for minimum loss  
+        
+        predict()
+            Prediction generator from Model  
+        
+        
+        Example
+        -------
+
+        >>> from rslearn.linear_model import LinearRegression
+        >>> Model = LinearRegression()
+        >>> X = np.array([10, 20, 30]) # List also works.
+        >>> y = np.array([5, 10, 15])
+        >>> Model.fit(X, y) # You can change learning_rate too
+        >>> print(f"Weight & Bias: {Model.get_weight_bias()}")
+        >>> prediction = Model.predict(np.array([40, 50]))
+        >>> print(f"Prediction: {prediction}")
+            
+
+        
+        """
+
+        self.weights = None
+        self.bias = None
+
+        valid_params = {"l1", "l2", "elastic_net", None}
+        if regulization not in valid_params:
+            raise ValueError(f"regulization parameter is not supported, supported Parameters {valid_params}")
+        
+        self.caclucate_error = self._regulizing_linear_helper(regulization=regulization, alpha=alpha, l1_ratio=l1_ratio)
+            
+    
+
+
+    def fit(self,
+            X ,
+            y , 
+            weights= None,
+            bias = None,
+            learning_rate : float = 0.01,
+            min_loss : float = 0.2,
+            max_itr : int = 18000
+            ):
+        """
+
+        Input Param*
+        __________
+        X = Data to Train 1D array, Dtype = np.array   
+
+        Y = True value a.k.a. original prediction 1D array, Dtype = np.array  
+
+        max_itr = loop to update weight and bias, Dtype = int and default = 18000  | No Input need  
+
+        learning_rate = how fast weights should update, Dtype = float, Default = 0.01  
+
+        weights = enter custom weight |  optional  
+
+        bias = enter custom bias |  optional  
+
+        min_loss = minimum loss where to stop the loop Default = 0.2 and its almost best for gradient descent  
+        -----------------
+
+        Change the `learning_rate` or Use `Scalers` if output or weights contains 'e' e.g -1.8038873e+163
+        """
+
+        
+
+        X = np.array(X)
+        y = np.array(y).reshape(-1)
+
+        if X.ndim == 1:
+            X = X.reshape(-1, 1)
+        
+        n_samples, n_feature = X.shape
+
+        np.random.seed(7)
+        if weights is None:
+            weights = np.random.uniform(0.2, 3, n_feature)
+        
+        if bias is None:
+            bias = 0
+
+        iteration  = 0
+
+        while iteration < max_itr:
+            pred = np.dot(X, weights) + bias # prediction
+
+            mse_error = self.caclucate_error.get_error(y_true=y, y_pred=pred, weights=weights)
+
+            if mse_error <= min_loss:
+                print(f"Model Succesfully Fitted at #{iteration} iteration")
+                break
+
+            loss = pred - y # Loss for Gradients
+            dw = (2/n_samples) * np.dot(X.T, loss) + self.caclucate_error.get_weight_gradient(weights=weights)
+            db = (2/n_samples) * np.sum(loss)
+
+            weights -= learning_rate * dw
+            bias -= learning_rate * db
+
+            if np.isnan(weights).any() or np.isnan(bias):
+                print("NaN detected, stopping training, Use Scalers to avoid it")
+                break
+
+            iteration += 1
+
+
+        
+        self.weights = weights
+        self.bias = bias
+
+    def get_weight_bias(self) -> np.array:
+        """Input = None, 
+        O/P - (np.array, float64)
+        >>> weights, bias = Model.get_weight_bias()
+        """
+
+        return (self.weights, self.bias)
+    
+    def predict(self, new_data : np.array) -> np.array:
+        """
+        Input Format = 1D or 2D np.array
+        Output Format = 1D np.array
+        """
+        if len(new_data) == 0:
+            raise ValueError("Got Empty Array")
+        
+        new_data = np.array(new_data)
+
+        if new_data.ndim == 1:
+            new_data = new_data.reshape(-1, 1)
+
+        return (np.dot(new_data, self.weights) + self.bias).round(2)
+
+    class _regulizing_linear_helper:
+        def __init__(self, alpha=0.1, regulization=None, l1_ratio = 0.5):
+            self.alpha = alpha
+            self.regulization = regulization
+            self.l1_ratio = l1_ratio
+        
+        def get_error(self, y_true, y_pred, weights):
+            mse_error = mse(y_true, y_pred)
+            if self.regulization is None:
+                return mse_error
+            
+            if self.regulization == "l1":
+                reg = self.alpha * np.sum(np.abs(weights))
+                return  mse_error + reg
+            
+            if self.regulization == "l2":
+                reg = self.alpha * np.sum(np.square(weights))
+                return mse_error + reg
+            
+            if self.regulization == "elastic_net":
+                l1 = self.alpha * self.l1_ratio
+                l2 = self.alpha * (1 - self.l1_ratio)
+
+                reg = l1 * np.sum(np.abs(weights)) + l2 * np.sum(np.square(weights))
+                return mse_error + reg
+        
+        def get_weight_gradient(self, weights):
+            if self.regulization == "l1":
+                return self.alpha * np.sign(weights)
+            
+            if self.regulization == "l2":
+                return 2 * self.alpha * weights
+            
+            if self.regulization == "elastic_net":
+                l1 = self.alpha * self.l1_ratio
+                l2 = self.alpha * (1 - self.l1_ratio)
+
+                return l1 * np.sign(weights) + 2 * l2 * weights
+
+            return 0
+
+
+
+
+
+    
+
+if __name__ == "__main__":
+    Model = LinearRegression()

rslearn/linear_model/_LogisticRegression.py

@@ -0,0 +1,212 @@
+"""
+Logistic Regression implementation using Gradient Descent.
+
+Notes
+-----
+- This implementation uses gradient descent for optimization.
+- Feature scaling is highly recommended for better convergence and performance.
+
+Recommended preprocessing:
+    from rslearn.preprocessing import StandardScaler, MinMaxScaler
+
+Example:
+    scaler = StandardScaler()
+    X = scaler.fit_transform(X)
+
+- Without scaling, the model may converge slowly or produce suboptimal results.
+"""
+
+import numpy as np
+
+
+class LogisticRegression:
+
+    """
+    Logistic Regression
+    -------------------
+    Logistic Regression for 1D and 2D metrics both with binary and Catogirical classification both supported  
+
+    use any Scaler for better result and accuracy specially in catogirical classification  
+
+    Parameters
+    ----------
+
+    solver: liblinear/solver/auto
+        liblinear for Binary Classification  
+        saga for Catogirical Classification
+        auto for automaticly chooses (Default)  
+    
+    lr: learning_rate  
+        Default `0.01`  
+    
+    Methords
+    --------
+    fit: function for fitting the model  
+        Parameters in function doc string
+    
+    predict: function for prediction after fitting  
+
+    Example
+    -------
+    >>> from rslearn.linear_model import LogisticRegression
+    >>> Model = LogisticRegression()
+    >>> Model.fit(X, y)
+    >>> pred = Model.predict(X_test)
+
+
+    """
+
+    def __init__(self, solver="auto", lr = 0.01):
+        if solver not in ["saga", "liblinear", "auto"]:
+            raise ValueError(f"Solver Must be saga or liblinear {solver}")
+
+        self.solver = solver
+        self.lr = lr
+        self.weights = None
+        self.bias = None
+
+    # Probablity predictor for catogirical classification
+    def predict_proba(self, X):
+        X = np.asarray(X)
+    
+        if self.solver == "liblinear":
+            z = X @ self.weights + self.bias
+            probs_1 = 1 / (1 + np.exp(-z))
+            probs_0 = 1 - probs_1
+            return np.vstack((probs_0, probs_1)).T
+    
+        else:
+            probs = [m.predict_proba(X)[:, 1] for m in self._cato_model.models]
+            probs = np.vstack(probs).T
+    
+            # normalize
+            probs = probs / probs.sum(axis=1, keepdims=True)
+            return probs
+
+    def fit(self, X, y, max_itr = 1000, ):
+
+        """
+        Function for fitting Logistic Regression Model
+
+        Parameters
+        ----------
+        X: feature set for model training
+            2D or 1D metrics | `np.array`, `DataFrame`  
+        
+        y: correct value for X features set
+            1D array | `np.array`  
+        
+        max_itr: maximum itration to loop though  
+            Default `1000`  
+        
+        Returns
+        -------
+        None
+        """
+
+        X = np.asarray(X)
+        y = np.asarray(y)
+        y = y.reshape(-1)
+
+        if len(X) != len(y):
+            raise ValueError(f"X and y are diffrent size {(len(X), len(y))}")
+
+        # Handling solvers in auto mode
+        if self.solver == "auto":
+            unique = np.unique(y)
+            if len(unique) == 2:
+                self.solver = "liblinear"
+            else:
+                self.solver = "saga"
+
+        # Diffrent condition for fit
+        if self.solver == "liblinear":
+            Model = _binary_fit(X=X, y=y, lr=self.lr)
+            self.weights, self.bias = Model.fit()
+        
+        else:
+            Model = _catogirical_fit(X=X, y=y)
+            Model.fit()
+            self._cato_model = Model
+
+    def predict(self, X):
+
+        """
+        Function for predict for Logistic Regression
+
+        Parameter
+        --------
+        X: new Data for prediction  
+            n_sample, n_features of X should be same as data on which model trained  
+            preferd `np.array`, `DataFrame`
+        """
+
+        X = np.asarray(X)
+
+
+        probs = self.predict_proba(X)
+
+        if probs.shape[1] == 2:
+            return (probs[:, 1] >= 0.5).astype(int)
+            
+        else:
+            return np.argmax(probs, axis=1)
+        
+                
+
+# For liblinear (Default)
+class _binary_fit:
+    def __init__(self,X , y, lr, max_itr : int = 1000):
+        self.lr = lr
+        self.X = X
+        self.y = y
+        self.max_itr = max_itr
+
+    def _sigmoid(self, z):
+        return 1 / (1 + np.exp(-z))
+
+    def fit(self):
+        X = self.X
+        y = self.y
+        n_rows, n_features = X.shape
+
+        weights = np.zeros(n_features)
+        bias = 0
+
+        for _ in range(self.max_itr):
+            z = np.dot(X, weights) + bias 
+            y_pred = self._sigmoid(z)
+
+            # Gradients
+            dw = (1/n_rows) * np.dot(X.T, (y_pred - y))
+            db = (1/n_rows) * np.sum(y_pred - y)
+
+            # update
+            weights -= self.lr * dw
+            bias -= self.lr * db
+
+        return weights, bias
+            
+
+# For Catogrical
+class _catogirical_fit:
+    def __init__(self, X, y):
+        self.X = X
+        self.y = y
+    
+    def fit(self):
+        X = self.X
+        y = self.y
+        self.models = []
+        self.classes = np.unique(y)
+
+        for c in self.classes:
+            model = LogisticRegression(solver="liblinear")
+            y_bin = (y == c).astype(int)
+            model.fit(X, y_bin)
+            self.models.append(model)
+
+    def predict(self, X):
+        probs = [m.predict_proba(X) for m in self.models]
+        probs = np.vstack(probs).T
+        return np.argmax(probs, axis=1)

rslearn/linear_model/__init__.py

@@ -0,0 +1,4 @@
+from ._LinearRegression import LinearRegression
+from ._LogisticRegression import LogisticRegression
+from ._regulizations import Ridge, Lasso, ElasticNet
+__all__ = ["LinearRegression", "LogisticRegression", "Ridge", "Lasso", "ElasticNet"]

rslearn/linear_model/_regulizations.py

@@ -0,0 +1,231 @@
+from rslearn.linear_model import LinearRegression
+
+"""
+This File Contains regulizing algorithams to avoid overfitting though the model  
+
+Algorithams Contains  
+----------------------
+- `Lasso`
+- `Ridge`
+- `ElasticNet`
+"""
+
+class Lasso:
+
+    """
+    Lasso l1 regulization for Avoid Overfitting though abs()  
+    NOTE: It uses LinearRegression Internly So make Sure to Scale youre Data and enter False in Scale Parameter in `fit()`  
+
+    Parameters
+    -----------
+
+    alpha: alpha value for Ridge, Lasso, ElasticNet  
+            Default: 0.1  
+        
+    l1_ratio: Lasso Ratio for Better ElasticNet Gradient and MSE  
+        Default: 0.5  
+
+    Returns
+    -------
+    None
+
+    Example
+    -------
+
+    >>> from rslearn.linear_model import Lasso
+    >>> LassoR = Lasso() # Using Default Parameters
+    >>> LassoR.fit(X, y, Scale=True) # Auto Scales Basicly for better performence use StandardScaler
+    >>> LassoR.predict(X_new)
+
+    """
+
+    def __init__(self, alpha=0.1, l1_score=0.5):
+        self.alpha = alpha
+        self.l1_score = l1_score
+        self.weights, self.bias = None
+    
+    def fit(self, X, y, Scale=True):
+
+        """
+        `fit()` Function For `Lasso` to Train The Model  
+
+        Parameters
+        ----------
+
+        X: array-like, 1D or 2D metrics for train model  
+
+        y: array-like, 1D or 2D metrics of Real Value for X features
+
+        Scaler: option to Scale Automaticly
+            Default: True, Use `StandardScaler` and select `False` For better results
+        
+        Returns
+        -------
+        None
+        """
+
+        model = LinearRegression(regulization="l1", alpha=self.alpha, l1_ratio=self.l1_score)
+
+        if Scale: # Use Scalers for better performance
+            X = X/max(X)
+            y = y/max(y)
+
+        
+        model.fit(X, y)
+
+        self.weights, self.bias = model.get_weight_bias()
+        self.model = model
+    
+    def predict(self, X_new):
+        prediction = self.model.predict(X_new)
+        return prediction
+    
+    def get_weight_bias(self):
+        return (self.weights, self.bias)
+
+
+class Ridge:
+    """
+    Ridge `l2` regulization for Avoid Overfitting though square()
+    NOTE: It uses LinearRegression Internly So make Sure to Scale youre Data and enter False in Scale Parameter in `fit()`  
+
+    Parameters
+    -----------
+
+    alpha: alpha value for Ridge, Lasso, ElasticNet  
+            Default: 0.1  
+        
+    l1_ratio: Lasso Ratio for Better ElasticNet Gradient and MSE  
+        Default: 0.5  
+
+    Returns
+    -------
+    None
+
+    Example
+    -------
+
+    >>> from rslearn.linear_model import Ridge
+    >>> RidgeR = Ridge() # Using Default Parameters
+    >>> RidgeR.fit(X, y, Scale=True) # Auto Scales Basicly for better performence use StandardScaler
+    >>> RidgeR.predict(X_new)
+
+    """
+    
+
+    def __init__(self, alpha=0.1, l1_score=0.5):
+        self.alpha = alpha
+        self.l1_score = l1_score
+        self.weights, self.bias = None
+    
+    def fit(self, X, y, Scale=True):
+        """
+        `fit()` Function For `Ridge` to Train The Model  
+
+        Parameters
+        ----------
+
+        X: array-like, 1D or 2D metrics for train model  
+
+        y: array-like, 1D or 2D metrics of Real Value for X features
+
+        Scaler: option to Scale Automaticly
+            Default: True, Use `StandardScaler` and select `False` For better results
+        
+        Returns
+        -------
+        None
+        """
+
+
+        model = LinearRegression(regulization="l2", alpha=self.alpha, l1_ratio=self.l1_score)
+
+        if Scale: # Use Scalers for better performance
+            X = X/max(X)
+            y = y/max(y)
+
+        
+        model.fit(X, y)
+
+        self.weights, self.bias = model.get_weight_bias()
+        self.model = model
+    
+    def predict(self, X_new):
+        prediction = self.model.predict(X_new)
+        return prediction
+    
+    def get_weight_bias(self):
+        return (self.weights, self.bias)
+
+class ElasticNet:
+    """
+    `ElasticNet` regulization for Avoid Overfitting by Combination of `l1`, `l2`  
+    NOTE: It uses LinearRegression Internly So make Sure to Scale youre Data and enter False in Scale Parameter in `fit()`  
+
+    Parameters
+    -----------
+
+    alpha: alpha value for Ridge, Lasso, ElasticNet  
+            Default: 0.1  
+        
+    l1_ratio: Lasso Ratio for Better ElasticNet Gradient and MSE  
+        Default: 0.5  
+
+    Returns
+    -------
+    None
+
+    Example
+    -------
+
+    >>> from rslearn.linear_model import ElasticNet
+    >>> En = ElasticNet() # Using Default Parameters
+    >>> En.fit(X, y, Scale=True) # Auto Scales Basicly for better performence use StandardScaler
+    >>> En.predict(X_new)
+
+    """
+
+
+    def __init__(self, alpha=0.1, l1_score=0.5):
+        self.alpha = alpha
+        self.l1_score = l1_score
+        self.weights, self.bias = None
+    
+    def fit(self, X, y, Scale=True):
+        """
+        `fit()` Function For `ElasticNet` to Train The Model  
+
+        Parameters
+        ----------
+
+        X: array-like, 1D or 2D metrics for train model  
+
+        y: array-like, 1D or 2D metrics of Real Value for X features
+
+        Scaler: option to Scale Automaticly
+            Default: True, Use `StandardScaler` and select `False` For better results
+        
+        Returns
+        -------
+        None
+        """
+
+
+        model = LinearRegression(regulization="elastic_net", alpha=self.alpha, l1_ratio=self.l1_score)
+
+        if Scale: # Use Scalers for better performance
+            X = X/max(X)
+            y = y/max(y)
+
+        
+        model.fit(X, y)
+
+        self.weights, self.bias = model.get_weight_bias()
+        self.model = model
+    
+    def predict(self, X_new):
+        prediction = self.model.predict(X_new)
+        return prediction
+    
+    def get_weight_bias(self):
+        return (self.weights, self.bias)

rslearn/metrics/__init__.py

@@ -0,0 +1,3 @@
+from ._regression import r2_score, mse, mae, rmse
+
+__all__ = ["r2_score", "mse", "mae", "rmse"]