Fixed the different evaluation metrics.

mini-batch-sgd-logistic-regression-wdbc.py

@@ -1,5 +1,7 @@
 import numpy as np
 import pandas as pd
+from matplotlib import pyplot as plt
+from sklearn.metrics import confusion_matrix, roc_auc_score
 
 class LogisticRegression:
     '''
@@ -105,7 +107,11 @@ class LogisticRegression:
 
             # if verbose, it shows the loss every 100 iterations and displays it
             if self.verbose and epoch % 100 == 0:
-                print(f"Iter {epoch:4d} – loss: {loss:.6f}")
+                precision = self.precision(self.x, self.y)
+                recall = self.recall(self.x, self.y)
+                f1_score = self.f1_score(self.x, self.y)
+                # 'au_roc = self.au_roc(self.x, self.y)
+                print(f"Iter {epoch:4d} – loss: {loss:.6f} | precision: {precision:.6f} | recall: {recall:.6f} | f1_score: {f1_score:.6f}")
 
             # tests whether the absolute change in loss is smaller than the tolerance
             if epoch > 1 and abs(self.loss[-2] - loss) < self.tol:
@@ -134,6 +140,104 @@ class LogisticRegression:
         y_true = np.asarray(y).astype(int)
         return np.mean(y_pred == y_true) # mean is calculated if Y values match
 
+    def confusion_matrix(self, x: pd.DataFrame, y: pd.Series,
+                         normalize: bool = False) -> np.ndarray:
+        """
+        Confusion Matrix
+        Returns a 2x2 matrix: [[TN, FP], [FN, TP]]
+        """
+        y_pred = self.predict(x)
+        y_true = np.asarray(y).astype(int)
+
+        cm = confusion_matrix(y_true, y_pred)
+
+        if normalize:
+            cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
+
+        return cm
+
+    def plot_confusion_matrix(self, x: pd.DataFrame, y: pd.Series,
+                              normalize: bool = False, title: str = "Confusion Matrix", sns=None) -> None:
+        """
+        Plot confusion matrix as a heatmap
+        """
+        cm = self.confusion_matrix(x, y, normalize)
+
+        plt.figure(figsize=(8, 6))
+        sns.heatmap(cm, annot=True, fmt='.2f' if normalize else 'd',
+                    cmap='Blues', cbar=False,
+                    xticklabels=['Predicted 0', 'Predicted 1'],
+                    yticklabels=['Actual 0', 'Actual 1'])
+        plt.title(title)
+        plt.ylabel('True Label')
+        plt.xlabel('Predicted Label')
+        plt.show()
+
+    def precision(self, x: pd.DataFrame, y: pd.Series) -> float:
+        """
+        Precision = TP / (TP + FP)
+        Measures how many of the predicted positives are actually positive
+        """
+        cm = self.confusion_matrix(x, y)
+        tp, fp = cm[1, 1], cm[0, 1]
+
+        if tp + fp == 0: #div by 0!!!
+            return 0.0
+
+        return tp / (tp + fp)
+
+    def recall(self, x: pd.DataFrame, y: pd.Series) -> float:
+        """
+        Recall = TP / (TP + FN)
+        ratio of true positives to all the positives in ground truth
+        """
+        cm = self.confusion_matrix(x, y)
+        tp, fn = cm[1, 1], cm[1, 0]
+
+        if tp + fn == 0:
+            return 0.0  # Avoid division by zero
+
+        return tp / (tp + fn)
+
+    def f1_score(self, x: np.ndarray | pd.DataFrame, y: np.ndarray | pd.Series) -> float:
+        """
+        F1-Score = 2 * ((Precision * Recall) / (Precision + Recall))
+        """
+        prec = self.precision(x, y)
+        rec = self.recall(x, y)
+
+        if prec + rec == 0:
+            return 0.0  # Avoid division by zero
+
+        return 2 * ((prec * rec) / (prec + rec))
+
+    '''
+    def predict_proba(self, x: np.ndarray | pd.DataFrame) -> np.ndarray:
+        """
+        Predict probability scores instead of binary labels
+        """
+        if isinstance(x, pd.DataFrame):
+            x = x.values
+
+        if self.w is None:
+            raise ValueError("Model not fitted yet")
+
+        # Add bias term if needed
+        if x.shape[1] == len(self.w) - 1:
+            x = np.column_stack([np.ones(x.shape[0]), x])
+
+        return self.sigmoid(x @ self.w)
+    def au_roc(self, x: np.ndarray | pd.DataFrame, y: np.ndarray | pd.Series) -> float:
+        """
+        Measures the model's ability to distinguish between classes
+        """
+        # make sure self.sigmoid outputs floats between 0 and 1
+        y_true = np.asarray(y).astype(int)
+        y_proba = self.predict_proba(x)
+
+        return roc_auc_score(y_true, y_proba)
+'''
+
 if __name__ == "__main__":
     columns = [
         'ID', 'Diagnosis',