blindscrambler 0.1.7__cp39-abi3-macosx_11_0_arm64.whl → 0.1.8__cp39-abi3-macosx_11_0_arm64.whl

blindscrambler/model/regression.py

@@ -12,6 +12,9 @@ import matplotlib.pyplot as plt
 from scipy import stats
 from typing import Tuple, Optional
 import warnings
+from torcheval.metrics import R2Score 
+import polars
+from sklearn.model_selection import train_test_split
 
 # add a linear Regression class:
 class LinearRegression:
@@ -24,193 +27,259 @@ class LinearRegression:
     Features:
     - Gradient-based optimization using PyTorch
     - Confidence intervals for parameters w_1 and w_0
-    - Visualization with confidence bands
     """
 
     def __init__(self, learning_rate: float = 0.01, max_epochs: int = 1000,
                  tolerance: float = 1e-6):
         
         """
+        The Constructor function for LinearRegression Class
+
+        Params:
+            - learning rate, for the gradient descent algorithm
+            - maximum number of epochs 
+            - tolerance, to know if things have converged
         """
 
-        # the main variables 
+        # make the arguments
         self.learning_rate = learning_rate
         self.max_epochs = max_epochs
         self.tolerance = tolerance
 
-        # Model parameters
-        self.w_0 = nn.Parameter(torch.randn(1, requires_grad=True))  # intercept
-        self.w_1 = nn.Parameter(torch.randn(1, requires_grad=True))  # slope
-
-        # training data storage
+        self.nsamples = None
         self.X_train = None
-        self.y_train = None 
+        self.y_train = None
+        self.X_test = None
+        self.y_test = None
 
-        # Model statistics for confidence intervals
-        self.n_samples = None
-        self.residual_sum_squares = None
-        self.X_mean = None
-        self.X_var = None
+        # to see if the instance is fitted or not
         self.fitted = False
 
-        # Loss function and optimizer
-        self.criterion = nn.MSELoss()
-        self.optimizer = optim.SGD([self.w_1, self.w_0], lr=self.learning_rate)
+        # the model parameters
+        self.w_0 = nn.Parameter(torch.randn(1, requires_grad=True)) # intercept
+        self.w_1 = nn.Parameter(torch.randn(1, requires_grad=True)) # slope
 
-        # Training history
-        self.loss_history = []
-        self.w0_history = []
-        self.w1_history = []
+        # loss function and its optimizer
+        self.lossfunction = nn.MSELoss()
+        self.optimizer = optim.SGD([self.w_0, self.w_1], lr = self.learning_rate)
 
+        # hold intermediate values of w_0 and w_1 and loss
+        self.inter_w_0 = []
+        self.inter_w_1 = []
+        self.inter_loss = []
+
+    
     def forward(self, X: torch.tensor) -> torch.tensor:
         """
+        Forward function for to specify linear model and compute the response
+
+        Params:
+            - X: torch.tensor
+            the input vector of size (n_samples, )
+        Returns:
+            - self.w_1 * X + self.w_0
+    `       the output is linear model result
+        
         """
         return self.w_1 * X + self.w_0
+
     
-    def fit(self, X: np.ndarray, y: np.ndarray) -> 'LinearRegression':
+    def fit(self, X_train: np.ndarray, y_train: np.ndarray, X_test: np.ndarray, y_test: np.ndarray) -> 'LinearRegression':
         """
+        The function where the training happens
+
+        Params:
+            - X, the training dataset of features 
+            - y, the training dataset of target
         """
-        # Convert to PyTorch tensors
-        self.X_train = torch.tensor(X, dtype=torch.float32)
-        self.y_train = torch.tensor(y, dtype=torch.float32)
-        self.n_samples = len(X)
-        
-        # Store statistics for confidence intervals
-        self.X_mean = float(np.mean(X))
-        self.X_var = float(np.var(X, ddof=1))  # Sample variance
-        
-        # Training loop
+
+        # convert to Pytorch tensors:
+        self.X_train = torch.tensor(X_train, dtype=torch.float32)
+        self.y_train = torch.tensor(y_train, dtype=torch.float32)
+        self.X_test = torch.tensor(X_test, dtype=torch.float32)
+        self.y_test = torch.tensor(y_test, dtype=torch.float32)
+        self.nsamples = len(X_train) # samples in the training set
+
+        # the training loop:
         prev_loss = float('inf')
-        
+
+        # reset history
+        self.inter_loss.clear()
+        self.inter_w_0.clear()
+        self.inter_w_1.clear()
+
         for epoch in range(self.max_epochs):
-            # Zero gradients
+            # reset the gradients
             self.optimizer.zero_grad()
-            
-            # Forward pass
-            y_pred = self.forward(self.X_train)
-            
-            # Compute loss
-            loss = self.criterion(y_pred, self.y_train)
-            
-            # Backward pass
+
+            # premature prediction
+            y_train_pred = self.forward(self.X_train)
+
+            # loss function
+            loss = self.lossfunction(y_train_pred, self.y_train)
+
+            # automatic gradient backward pass 
             loss.backward()
-            
-            # Update parameters
+
+            # update model parameters
             self.optimizer.step()
-            
-            # Store loss history
-            current_loss = loss.item()
-            self.loss_history.append(current_loss)
-            # Track parameter history (after update)
-            with torch.no_grad():
-                self.w0_history.append(float(self.w_0.item()))
-                self.w1_history.append(float(self.w_1.item()))
-            
-            # Check for convergence
+
+            # get the current loss and save it 
+            current_loss = float(loss.detach().item())
+
+            # save intermediate loss and model parameters 
+            self.inter_loss.append(current_loss)
+            self.inter_w_0.append(float(self.w_0.detach().item()))
+            self.inter_w_1.append(float(self.w_1.detach().item()))
+
             if abs(prev_loss - current_loss) < self.tolerance:
                 print(f"Converged after {epoch + 1} epochs")
                 break
-            
+
             prev_loss = current_loss
-        
-        # Compute residual sum of squares for confidence intervals
-        with torch.no_grad():
-            y_pred = self.forward(self.X_train)
-            residuals = self.y_train - y_pred
-            self.residual_sum_squares = float(torch.sum(residuals ** 2))
-        
+
+        # make predictions on the test set
+        y_test_pred = self.forward(self.X_test)
+
+        # create an R^2 metric type 
+        R2 = R2Score()
+        R2.update(y_test_pred, self.y_test)
+        print("The R2 score for the test set is :", R2.compute())
+
         self.fitted = True
-        return self
-    
+        return self 
+
     def predict(self, X: np.ndarray) -> np.ndarray:
         """
-        Make predictions on new data.
-        
-        Args:
-            X: Input features of shape (n_samples,)
-            
+        Make predictions on the new/unseen data
+
+        Params:
+            - feature vector X for the test set.
         Returns:
-            Predictions as numpy array
+            - predictions in a numpy array
         """
+
+        # making sure that the model is fitted lol
         if not self.fitted:
             raise ValueError("Model must be fitted before making predictions")
         
+        # make it a tensor
         X_tensor = torch.tensor(X, dtype=torch.float32)
-        
+
         with torch.no_grad():
             predictions = self.forward(X_tensor)
-        
+
         return predictions.numpy()
+
     
-    def analysis_plot(self, w_0: Optional[float] = None, w_1: Optional[float] = None):
+    def analysis_plot(self, show: bool = True, save_path: Optional[str] = None):
         """
-        Create a 2x2 analysis figure showing:
-        - Original data and fitted regression line
+        Create a 2x2 figure showing:
+        - Original data with fitted regression line
         - Training loss over epochs
-        - Intercept (w_0) trajectory over epochs
-        - Slope (w_1) trajectory over epochs
-
-        Args:
-            w_0: Intercept to plot final fit; if None, uses current self.w_0
-            w_1: Slope to plot final fit; if None, uses current self.w_1
+        - w0 trajectory over epochs
+        - w1 trajectory over epochs
         """
-        if self.X_train is None or self.y_train is None:
-            raise ValueError("No training data found. Fit the model before plotting.")
-
-        # Resolve parameters for plotting
-        if w_0 is None:
-            w_0 = float(self.w_0.detach().cpu().item())
-        if w_1 is None:
-            w_1 = float(self.w_1.detach().cpu().item())
-
-        X_np = self.X_train.detach().cpu().numpy().reshape(-1)
-        y_np = self.y_train.detach().cpu().numpy().reshape(-1)
-
-        # Build line for fit
-        x_line = np.linspace(X_np.min(), X_np.max(), 200)
-        y_line = w_1 * x_line + w_0
-
-        fig, axes = plt.subplots(2, 2, figsize=(12, 8))
-
-        # 1) Data + fit
-        ax = axes[0, 0]
-        ax.scatter(X_np, y_np, color='tab:blue', alpha=0.7, label='Data')
-        ax.plot(x_line, y_line, color='tab:red', label=f'Fit: y={w_1:.3f}x+{w_0:.3f}')
-        ax.set_title('Data and Fitted Line')
-        ax.set_xlabel('X')
-        ax.set_ylabel('y')
-        ax.legend()
+        if not self.fitted:
+            raise ValueError("Model must be fitted before plotting.")
+        if len(self.inter_loss) == 0:
+            warnings.warn("No training history recorded; plots may be empty.")
 
-        # 2) Loss history
-        ax = axes[0, 1]
-        if len(self.loss_history) > 0:
-            ax.plot(range(1, len(self.loss_history) + 1), self.loss_history, color='tab:green')
-        ax.set_title('Training Loss')
-        ax.set_xlabel('Epoch')
-        ax.set_ylabel('MSE Loss')
-        ax.grid(True, linestyle='--', alpha=0.3)
-
-        # 3) w_0 history
-        ax = axes[1, 0]
-        if len(self.w0_history) > 0:
-            ax.plot(range(1, len(self.w0_history) + 1), self.w0_history, color='tab:purple')
-        ax.axhline(w_0, color='gray', linestyle='--', alpha=0.6, label='Final w_0')
-        ax.set_title('w_0 (Intercept) over Epochs')
-        ax.set_xlabel('Epoch')
-        ax.set_ylabel('w_0')
-        ax.legend()
-        ax.grid(True, linestyle='--', alpha=0.3)
-
-        # 4) w_1 history
-        ax = axes[1, 1]
-        if len(self.w1_history) > 0:
-            ax.plot(range(1, len(self.w1_history) + 1), self.w1_history, color='tab:orange')
-        ax.axhline(w_1, color='gray', linestyle='--', alpha=0.6, label='Final w_1')
-        ax.set_title('w_1 (Slope) over Epochs')
-        ax.set_xlabel('Epoch')
-        ax.set_ylabel('w_1')
+        fig, axs = plt.subplots(2, 2, figsize=(12, 8))
+
+        # 1) Data + fitted line
+        ax = axs[0, 0]
+
+        # scatter only the test set
+        if self.X_test is not None and self.y_test is not None:
+            ax.scatter(
+                self.X_test.detach().cpu().numpy(),
+                self.y_test.detach().cpu().numpy(),
+                s=12, alpha=0.7, label="Test"
+            )
+            # Line range from min/max of test X only
+            xmin = float(torch.min(self.X_test).item())
+            xmax = float(torch.max(self.X_test).item())
+        else:
+            xmin, xmax = -1.0, 1.0
+
+        x_line = torch.linspace(xmin, xmax, 200)
+        with torch.no_grad():
+            y_line = self.forward(x_line).detach().cpu().numpy()
+            w0 = float(self.w_0.detach().item())
+            w1 = float(self.w_1.detach().item())
+        ax.plot(
+            x_line.detach().cpu().numpy(),
+            y_line,
+            color="crimson",
+            label=f"Fit: y = {w1:.4f} x + {w0:.4f}"
+        )
+
+        ax.set_title("Test Data and Fitted Line")
+        ax.set_xlabel("X")
+        ax.set_ylabel("y")
         ax.legend()
-        ax.grid(True, linestyle='--', alpha=0.3)
+        ax.grid(True, alpha=0.2)
+
+        # 2) Loss
+        ax = axs[0, 1]
+        if self.inter_loss:
+            ax.plot(range(1, len(self.inter_loss) + 1), self.inter_loss, color="steelblue")
+        ax.set_title("Training Loss (MSE)")
+        ax.set_xlabel("Epoch")
+        ax.set_ylabel("Loss")
+        ax.grid(True, alpha=0.2)
+
+        # 3) w0 trajectory
+        ax = axs[1, 0]
+        if self.inter_w_0:
+            ax.plot(range(1, len(self.inter_w_0) + 1), self.inter_w_0, color="darkgreen")
+        ax.set_title("w0 trajectory")
+        ax.set_xlabel("Epoch")
+        ax.set_ylabel("w0")
+        ax.grid(True, alpha=0.2)
+
+        # 4) w1 trajectory
+        ax = axs[1, 1]
+        if self.inter_w_1:
+            ax.plot(range(1, len(self.inter_w_1) + 1), self.inter_w_1, color="darkorange")
+        ax.set_title("w1 trajectory")
+        ax.set_xlabel("Epoch")
+        ax.set_ylabel("w1")
+        ax.grid(True, alpha=0.2)
+
+        fig.tight_layout()
+        if save_path:
+            fig.savefig(save_path, dpi=150, bbox_inches="tight")
+        if show:
+            plt.show()
+        else:
+            plt.close(fig)
+        return fig, axs
+    
+if __name__ == "__main__":
+
+    # the path of the file
+    csv_path = "/Users/syedraza/Desktop/UAH/Classes/Fall2025/CPE586-MachineLearning/HWs/hw3/Hydropower.csv"
+
+    # read in the needed data
+    data_frame = polars.read_csv(csv_path)["BCR", "AnnualProduction"]
+
+    # separate out features and targets
+    X = data_frame["BCR"]
+    y = data_frame["AnnualProduction"]
+
+    # train test split this
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
+
+    # make a LinearRegression() instance
+    model = LinearRegression()
+
+    # .fit() takes test set as well because it has to calculate the R2 score
+    model.fit(X_train, y_train, X_test, y_test)
+
+    # make predictions
+    predictions = model.predict(X_test)
 
-        plt.tight_layout()
-        return fig, axes
+    # make the required plots
+    model.analysis_plot()

{blindscrambler-0.1.7.dist-info → blindscrambler-0.1.8.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: blindscrambler
-Version: 0.1.7
+Version: 0.1.8
 Requires-Dist: matplotlib>=3.10.6
 Requires-Dist: numpy>=2.3.3
 Requires-Dist: polars>=1.34.0
 Requires-Dist: scikit-learn>=1.7.2
 Requires-Dist: scipy>=1.16.2
 Requires-Dist: torch>=2.8.0
+Requires-Dist: torcheval>=0.0.7
 Requires-Dist: twine>=6.1.0
 Summary: Add your description here
 Author-email: blindscramblergh <blindscrambler@gmail.com>

{blindscrambler-0.1.7.dist-info → blindscrambler-0.1.8.dist-info}/RECORD

@@ -1,5 +1,5 @@
-blindscrambler-0.1.7.dist-info/METADATA,sha256=Jnz2SO-4sk-teZcAoH5cHZ4zAMnmDISbMBmK8rhpidc,501
-blindscrambler-0.1.7.dist-info/WHEEL,sha256=vpqC0tRn_8bTHidvtrPbrnFQPZnrhuKzsjDdeKwCd58,102
+blindscrambler-0.1.8.dist-info/METADATA,sha256=8Zyi1rLMfBYCXQ4_2llZm6qBHGBmGmPsKzRH6pMNoQQ,533
+blindscrambler-0.1.8.dist-info/WHEEL,sha256=vpqC0tRn_8bTHidvtrPbrnFQPZnrhuKzsjDdeKwCd58,102
 blindscrambler/__init__.py,sha256=fSGH3-DvmAl8iABUbfGYKYKfQ025MVuih4VPm_wbUqQ,148
 blindscrambler/_core.abi3.so,sha256=4uKUtCwAO1Hbvzv0FXAt38rEHYbg-Quio8CdkJ_UMrk,440112
 blindscrambler/_core.pyi,sha256=b6oJaUXUzEzqUE5rpqefV06hl8o_JCU8pgKgIIzQgmc,33
@@ -10,6 +10,6 @@ blindscrambler/distributions/cvdistributions.py,sha256=lgZnlYdlCJEhk6K4cAkZmtIED
 blindscrambler/matrix/__init__.py,sha256=qlItVU8AVj_mP2NUJ3gor-lsovxk3Wxf5tUfKynoUbg,157
 blindscrambler/matrix/elementary.py,sha256=hArZLiBTA_vW1EZ0RniECf6ybJiJxO7KNuVHb_TZFQU,3987
 blindscrambler/model/__init__.py,sha256=CUXjl7w9exeF60zz0pjhD2SX8BLlH4Q5NXjEx_azznQ,71
-blindscrambler/model/regression.py,sha256=srWs8XueH8oc62k_8jJJtTnBWfH2tq1CSf0iO0j4JUE,7061
+blindscrambler/model/regression.py,sha256=Z1RptPbZ68NZByHG0N530ZocLOmcWs34eOWAoPqw1is,8792
 blindscrambler/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blindscrambler-0.1.7.dist-info/RECORD,,
+blindscrambler-0.1.8.dist-info/RECORD,,