Metric class

Author: cbbcbail

src/flexibleSubsetSelection/algorithm.py

@@ -1,5 +1,7 @@
 # --- Imports ------------------------------------------------------------------
 
+import math
+
 # Third party
 import cvxpy as cp
 import gurobipy as gp
@@ -34,8 +36,8 @@ def randomSample(
     """
     rng = np.random.default_rng(seed)
     indices = rng.choice(datasetSize[0], size=subsetSize, replace=False)
-    z = np.zeros(datasetSize[0])
-    z[indices] = 1
+    z = np.zeros(datasetSize[0], dtype=bool)
+    z[indices] = True
     return z, indices
 
 

src/flexibleSubsetSelection/dataset.py

@@ -195,7 +195,7 @@ def metrics(self) -> list[str]:
         Returns:
             A list of metric names.
         """
-        return list(self._metrics)
+        return self._metrics
 
     def compute(
         self, 
@@ -220,24 +220,16 @@ def compute(
         if array is None:
             array = "original"
 
-        if features is not None:
-            try:
-                indices = [self.features.index(f) for f in features]
-            except ValueError as e:
-                errorMessage = "Feature not found in 'compute()'."
-                log.exception(errorMessage)
-                raise RuntimeError(errorMessage) from e
         for name, function in metric.items():
             self._metrics[name] = Metric(
                 dataset = self, 
                 name = name, 
                 function = function, 
                 array = array, 
                 params = params, 
-                indices = indices
+                features = features
             )
 
-
     def scale(
         self,
         interval: tuple[float, float] | None = None,
@@ -248,8 +240,7 @@ def scale(
 
         Args:
             interval: The interval to scale the data to.
-            features: The features to scale. All features will be scaled if
-                unspecified.
+            features: The features to scale. All will scale if unspecified
 
         Raises:
             ValueError: if features are not found
@@ -283,8 +274,7 @@ def discretize(
 
         Args:
             bins: Number of bins to use, bins in each feature, or bin edges.
-            features: List of features to use for the binning. All features will
-                be encoded if unspecified.
+            features: List of features to bin. All will bin if unspecified.
             strategy: sklearn KBinsDiscretizer strategy to use.
 
         Raises:
@@ -315,8 +305,7 @@ def encode(
         assuming they are discrete.
 
         Args:
-            features: The features to use for the binning. All features will be
-                encoded if unspecified.
+            features: The features to encode. All will encode if unspecified.
             dimensions: The number of dimensions to take the encoding in
 
         Raises:
@@ -373,34 +362,34 @@ def save(
         log.info("Data successfully saved at '%s'.", filePath)
 
     def __repr__(self) -> str:
-        transformString = (
+        transformStr = (
             f", transforms=original→{'→'.join(self._transforms.queued[1:])}"
             if len(self._transforms) > 1
             else ""
         )
         return (
             f"Dataset(name='{self.name}', size={self.size}, "
-            f"features={self.features} {transformString})"
+            f"features={self.features} {transformStr})"
         )
 
     def __str__(self) -> str:
         transforms = self._transforms.queued[1:]
         if len(transforms) == 0:
-            transformString = ""
+            transformStr = ""
         elif len(transforms) == 1:
-            transformString = f"{transforms[0]}"
+            transformStr = f"{transforms[0]}"
         elif len(transforms) == 2:
-            transformString = f"{transforms[0]} and {transforms[1]}"
+            transformStr = f"{transforms[0]} and {transforms[1]}"
         else:
-            transformString = f"{', '.join(transforms[:-1])} and {transforms[-1]}"
+            transformStr = f"{', '.join(transforms[:-1])} and {transforms[-1]}"
 
-        featureString = (
+        featureStr = (
             f"[{', '.join(map(str, self.features[:3]))}"
             f"{', ...' if len(self.features) > 3 else ''}]"
         )
         return (
             f"Dataset {self.name}: {self.size[0]} rows x "
-            f"{self.size[1]} features {featureString} {transformString}"
+            f"{self.size[1]} features {featureStr} {transformStr}"
         )
 
     def __len__(self) -> int:
@@ -411,13 +400,15 @@ def __len__(self) -> int:
 
     def __getattr__(self, attr: str) -> np.ndarray:
         """
-        Returns the specified transformed version of the dataset.
+        Returns paramters of the dataset.
 
         Args:
-            attr: Specify the name of a transform function
+            attr: Specify the parameter to get
         """
         if attr in self._transforms.queued:
             return self._transforms[attr]
+        elif attr in self._metrics:
+            return self._metrics[attr]()
         else:
             raise AttributeError(f"'Dataset' object has no attribute '{attr}'")
 

src/flexibleSubsetSelection/metric.py

@@ -10,7 +10,6 @@
 from sklearn.cluster import KMeans
 
 # Local files
-from .dataset import Dataset
 from . import logger
 
 # Setup logger
@@ -25,12 +24,12 @@ class Metric:
 
     def __init__(
         self,
-        dataset: Dataset,
+        dataset: "Dataset",
         name: str,
         function: Callable,
         array: str,
         params: dict[str, Any] | None = None,
-        indices: list[int]| None = None
+        features: list[int]| None = None
     ):
         """
         Initialize a metric with a metric function and additional parameters
@@ -39,7 +38,7 @@ def __init__(
         self.name = name
         self.params = params
         self.array = array
-        self._indices = indices
+        self._features = features
         self._dataset = dataset 
         self._value = None
 
@@ -48,8 +47,15 @@ def __init__(
     def __call__(self):
         if self._value is None:
             array = getattr(self._dataset, self.array)
-            if self._indices is not None:
-                array = array[:, self._indices]
+            if self._features is not None:
+                try:
+                    features = self._dataset.features
+                    indices = [features.index(f) for f in self._features]
+                    array = array[:, indices]
+                except ValueError as e:
+                    errorMessage = "Feature not found in 'compute()'."
+                    log.exception(errorMessage)
+                    raise RuntimeError(errorMessage) from e
             if self.params is None:
                 self._value = self.function(array)
             else:
@@ -113,7 +119,6 @@ def discreteDistribution(array: np.ndarray) -> np.ndarray:
     """
     return np.mean(array, axis=0)
 
-
 def clusterCenters(array: np.ndarray, k: int) -> np.ndarray:
     """
     Returns the cluster centers of the k-means clustering for k clusters of the

src/flexibleSubsetSelection/objective.py

@@ -171,7 +171,6 @@ def emdCategorical(subset, dataset, features, categorical, categories):
 
 
 def entropy(array: np.ndarray) -> float:
-    counts = Counter(map(tuple, array))
-    total = sum(counts.values())
-    probabilities = np.array(list(counts.values())) / total
-    return np.sum(probabilities * np.log(probabilities))
+    _, counts = np.unique(array, axis=0, return_counts=True)
+    probs = counts / counts.sum()
+    return np.sum(probs * np.log(probs))

src/flexibleSubsetSelection/subset.py

@@ -62,13 +62,6 @@ def __init__(
         self.loss = loss
         log.info("Created %s.", self)
 
-    @property
-    def transforms(self) -> list[str]:
-        """
-        Expose available dataset transformations (mirrored from dataset).
-        """
-        return self.dataset.transforms
-
     @classmethod
     def load(
         cls,
@@ -112,7 +105,7 @@ def save(
         name: str = None,
     ) -> None:
         """
-        Save the subset to pickle for convenience or to csv for portability.
+        Save the subset to pickle for convenience or csv for portability.
 
         Args:
             fileType: The file format to save the data: 'pickle' or 'csv'.
@@ -183,23 +176,35 @@ def __getattr__(self, attr: str) -> np.ndarray:
     def __len__(self) -> int:
         return self.size[0]
 
+    @property
+    def transforms(self) -> list[str]:
+        """
+        Expose available dataset transformations (mirrored from dataset).
+        """
+        return self.dataset.transforms
+
     @staticmethod
-    def select(array: np.ndarray, z: np.ndarray, selectBy: str) -> np.ndarray:
+    def select(
+        array: np.ndarray, 
+        z: np.ndarray[bool], 
+        selectBy: str
+    ) -> np.ndarray:
         """
-        Selects a subset from array according to indicator z
+        Selects a subset from array according to indicator vector z.
 
         Args:
             array: The array to select from.
             z: The indicator vector indicating which elements to select.
-            selectBy: The method to select the subset (row or matrix).
+            selectBy: 'row' for row selection of tabular data or 'matrix' for 
+                selection from square matrix e.g. distance matrix
 
         Returns: The selected subset from the array.
 
         Raises: ValueError: If an unknown selection method is specified.
         """
         if selectBy == "row":
-            return array[z == 1]
+            return array[z]
         elif selectBy == "matrix":
-            return array[z == 1][:, z == 1]
+            return array[z][:, z]
         else:
             raise ValueError("Unknown selection method specified.")