Merge pull request #208 from siapy/fix

Author: janezlapajne

docs/api/models/metrics.md

@@ -0,0 +1 @@
+::: siapy.optimizers.metrics

docs/api/optimizers/metrics.md

@@ -96,11 +96,10 @@ nav:
           - Features: api/features/features.md
           - Helpers: api/features/helpers.md
           - Spectral Indices: api/features/spectral_indices.md
-      - Models:
-          - Metrics: api/models/metrics.md
       - Optimizers:
           - Configs: api/optimizers/configs.md
           - Evaluators: api/optimizers/evaluators.md
+          - Metrics: api/models/metrics.md
           - Optimizers: api/optimizers/optimizers.md
           - Parameters: api/optimizers/parameters.md
           - Scorers: api/optimizers/scorers.md

mkdocs.yml

@@ -49,4 +49,5 @@ def generate_regression_target(
 
 
 def merge_signals_from_multiple_cameras(data: "TabularDatasetData") -> None:
-    data.signals.copy()
+    # TODO: Implement the function to merge signals from multiple cameras
+    pass

pdm.lock

@@ -1,10 +1,12 @@
 from abc import ABC, abstractmethod
-from typing import Any, Iterable
+from dataclasses import dataclass
+from typing import Any, Iterable, Optional
 
 import pandas as pd
 from pydantic import BaseModel, ConfigDict
 
 from siapy.core.exceptions import InvalidInputError
+from siapy.entities import Signatures
 
 from .helpers import generate_classification_target, generate_regression_target
 
@@ -88,7 +90,7 @@ def reset_index(self) -> "ClassificationTarget":
 
 class RegressionTarget(Target):
     value: pd.Series
-    name: str
+    name: str = "value"
 
     def __getitem__(self, indices: Any) -> "RegressionTarget":
         value = self.value.iloc[indices]
@@ -105,7 +107,7 @@ def from_iterable(cls, data: Iterable[Any]) -> "RegressionTarget":
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> "RegressionTarget":
         value = pd.Series(data["value"], name="value")
-        name = data["name"]
+        name = data["name"] if "name" in data else "value"
         return cls(value=value, name=name)
 
     def to_dict(self) -> dict[str, Any]:
@@ -121,42 +123,38 @@ def reset_index(self) -> "RegressionTarget":
         return RegressionTarget(value=self.value.reset_index(drop=True), name=self.name)
 
 
-class TabularDatasetData(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-    pixels: pd.DataFrame
-    signals: pd.DataFrame
+@dataclass
+class TabularDatasetData:
+    signatures: Signatures
     metadata: pd.DataFrame
     target: Target | None = None
 
-    def __init__(self, *args: Any, **kwargs: Any):
-        super().__init__(*args, **kwargs)
-        self._validate_lengths()
+    def __len__(self) -> int:
+        return len(self.signatures)
 
-    def __setattr__(self, name: str, value: Any) -> None:
-        super().__setattr__(name, value)
-        if name in self.model_fields.keys():
-            self._validate_lengths()
+    def __repr__(self) -> str:
+        return f"TabularDatasetData(signatures={self.signatures}, metadata={self.metadata}, target={self.target})"
 
     def __getitem__(self, indices: Any) -> "TabularDatasetData":
-        pixels = self.pixels.iloc[indices]
-        signals = self.signals.iloc[indices]
+        signatures = self.signatures[indices]
         metadata = self.metadata.iloc[indices]
+        if isinstance(metadata, pd.Series):
+            metadata = pd.DataFrame(metadata).T
         target = None if self.target is None else self.target.__getitem__(indices)
-        return TabularDatasetData(pixels=pixels, signals=signals, metadata=metadata, target=target)
+        return TabularDatasetData(signatures=signatures, metadata=metadata, target=target)
 
-    def __len__(self) -> int:
-        return len(self.pixels)
+    def __post_init__(self) -> None:
+        self._validate_lengths()
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> "TabularDatasetData":
-        pixels = pd.DataFrame(data["pixels"])
-        signals = pd.DataFrame(data["signals"])
+        signatures = Signatures.from_dict({"pixels": data["pixels"], "signals": data["signals"]})
         metadata = pd.DataFrame(data["metadata"])
         target = TabularDatasetData.target_from_dict(data.get("target", None))
-        return cls(pixels=pixels, signals=signals, metadata=metadata, target=target)
+        return cls(signatures=signatures, metadata=metadata, target=target)
 
     @staticmethod
-    def target_from_dict(data: dict[str, Any] | None) -> Target | None:
+    def target_from_dict(data: dict[str, Any] | None = None) -> Optional[Target]:
         if data is None:
             return None
 
@@ -172,14 +170,13 @@ def target_from_dict(data: dict[str, Any] | None) -> Target | None:
             raise InvalidInputError(data, "Invalid target dict.")
 
     def _validate_lengths(self) -> None:
-        if not (len(self.pixels) == len(self.signals) == len(self.metadata)):
+        if len(self.signatures) != len(self.metadata):
             raise InvalidInputError(
                 {
-                    "pixels_length": len(self.pixels),
-                    "signals_length": len(self.signals),
+                    "signatures_length": len(self.signatures),
                     "metadata_length": len(self.metadata),
                 },
-                "Lengths of pixels, signals, and metadata must be equal",
+                "Lengths of signatures and metadata must be equal",
             )
         if self.target is not None and len(self.target) != len(self):
             raise InvalidInputError(
@@ -190,25 +187,77 @@ def _validate_lengths(self) -> None:
                 "Target length must be equal to the length of the dataset.",
             )
 
+    def set_attributes(
+        self,
+        *,
+        signatures: Signatures | None = None,
+        metadata: pd.DataFrame | None = None,
+        target: Target | None = None,
+    ) -> "TabularDatasetData":
+        current_data = self.copy()
+        signatures = signatures if signatures is not None else current_data.signatures
+        metadata = metadata if metadata is not None else current_data.metadata
+        target = target if target is not None else current_data.target
+        return TabularDatasetData(signatures=signatures, metadata=metadata, target=target)
+
     def to_dict(self) -> dict[str, Any]:
+        signatures_dict = self.signatures.to_dict()
         return {
-            "pixels": self.pixels.to_dict(),
-            "signals": self.signals.to_dict(),
+            "pixels": signatures_dict["pixels"],
+            "signals": signatures_dict["signals"],
             "metadata": self.metadata.to_dict(),
             "target": self.target.to_dict() if self.target is not None else None,
         }
 
     def to_dataframe(self) -> pd.DataFrame:
-        combined_df = pd.concat([self.pixels, self.signals, self.metadata], axis=1)
+        combined_df = pd.concat([self.signatures.to_dataframe(), self.metadata], axis=1)
         if self.target is not None:
             target_series = self.target.to_dataframe()
             combined_df = pd.concat([combined_df, target_series], axis=1)
         return combined_df
 
+    def to_dataframe_multiindex(self) -> pd.DataFrame:
+        signatures_df = self.signatures.to_dataframe_multiindex()
+
+        metadata_columns = pd.MultiIndex.from_tuples(
+            [("metadata", col) for col in self.metadata.columns], names=["category", "field"]
+        )
+        metadata_df = pd.DataFrame(self.metadata.values, columns=metadata_columns)
+
+        combined_df = pd.concat([signatures_df, metadata_df], axis=1)
+
+        if self.target is not None:
+            target_df = self.target.to_dataframe()
+            if isinstance(self.target, ClassificationTarget):
+                target_columns = pd.MultiIndex.from_tuples(
+                    [("target", col) for col in target_df.columns],
+                    names=["category", "field"],
+                )
+            elif isinstance(self.target, RegressionTarget):
+                target_columns = pd.MultiIndex.from_tuples(
+                    [("target", self.target.name)],
+                    names=["category", "field"],
+                )
+            else:
+                raise InvalidInputError(
+                    self.target,
+                    "Invalid target type. Expected ClassificationTarget or RegressionTarget.",
+                )
+            target_df = pd.DataFrame(target_df.values, columns=target_columns)
+            combined_df = pd.concat([combined_df, target_df], axis=1)
+
+        return combined_df
+
     def reset_index(self) -> "TabularDatasetData":
         return TabularDatasetData(
-            pixels=self.pixels.reset_index(drop=True),
-            signals=self.signals.reset_index(drop=True),
+            signatures=self.signatures.reset_index(),
             metadata=self.metadata.reset_index(drop=True),
             target=self.target.reset_index() if self.target is not None else None,
         )
+
+    def copy(self) -> "TabularDatasetData":
+        return TabularDatasetData(
+            signatures=self.signatures.copy(),
+            metadata=self.metadata.copy(),
+            target=self.target.model_copy() if self.target is not None else None,
+        )

siapy/datasets/helpers.py

@@ -79,8 +79,7 @@ def process_image_data(self) -> None:
 
     def generate_dataset_data(self, mean_signatures: bool = True) -> TabularDatasetData:
         self._check_data_entities()
-        pixels_dfs = []
-        signals_dfs = []
+        signatures_dfs = []
         metadata_dfs = []
         for entity in self.data_entities:
             signatures_df = entity.signatures.to_dataframe().dropna()
@@ -104,17 +103,13 @@ def generate_dataset_data(self, mean_signatures: bool = True) -> TabularDatasetD
                 "Sanity check failed! The columns in metadata_df do not match MetaDataEntity fields."
             )
 
-            signatures = Signatures.from_dataframe(signatures_df)
-
-            pixels_dfs.append(signatures.pixels.df)
-            signals_dfs.append(signatures.signals.df)
+            signatures_dfs.append(signatures_df)
             metadata_dfs.append(metadata_df)
 
-        return TabularDatasetData(
-            pixels=pd.concat(pixels_dfs, ignore_index=True),
-            signals=pd.concat(signals_dfs, ignore_index=True),
-            metadata=pd.concat(metadata_dfs, ignore_index=True),
-        )
+        signatures_concat = pd.concat(signatures_dfs, ignore_index=True)
+        metadata_concat = pd.concat(metadata_dfs, ignore_index=True)
+        signatures = Signatures.from_dataframe(signatures_concat)
+        return TabularDatasetData(signatures=signatures, metadata=metadata_concat)
 
     def _check_data_entities(self) -> None:
         if not self.data_entities:

siapy/datasets/schemas.py

@@ -8,7 +8,7 @@
 import pandas as pd
 from numpy.typing import NDArray
 
-from siapy.core.exceptions import InvalidInputError
+from siapy.core.exceptions import InvalidInputError, InvalidTypeError
 
 __all__ = [
     "Pixels",
@@ -42,9 +42,11 @@ def __len__(self) -> int:
     def __repr__(self) -> str:
         return f"Pixels(\n{self.df}\n)"
 
-    def __getitem__(self, idx: int) -> PixelCoordinate:
-        row = self.df.iloc[idx]
-        return PixelCoordinate(x=row[self.coords.X], y=row[self.coords.Y])
+    def __getitem__(self, indices: Any) -> "Pixels":
+        df_slice = self.df.iloc[indices]
+        if isinstance(df_slice, pd.Series):
+            df_slice = df_slice.to_frame().T
+        return Pixels(df_slice)
 
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, Pixels):
@@ -76,6 +78,7 @@ def df_homogenious(self) -> pd.DataFrame:
         return df_homo
 
     def u(self) -> "pd.Series[float]":
+        # TODO: change to u -> x
         return self.df[self.coords.X]
 
     def v(self) -> "pd.Series[float]":
@@ -96,13 +99,31 @@ def as_type(self, dtype: type) -> "Pixels":
         converted_df[self.coords.Y] = converted_df[self.coords.Y].astype(dtype)
         return Pixels(converted_df)
 
+    def get_coordinate(self, idx: int) -> PixelCoordinate:
+        row = self.df.iloc[idx]
+        return PixelCoordinate(x=row[self.coords.X], y=row[self.coords.Y])
+
+
+def validate_pixel_input_dimensions(df: pd.DataFrame | pd.Series) -> None:
+    if isinstance(df, pd.Series):
+        raise InvalidTypeError(
+            input_value=df,
+            allowed_types=pd.DataFrame,
+            message="Expected a DataFrame, but got a Series.",
+        )
+
+    if df.empty:
+        raise InvalidInputError(
+            message="Input DataFrame is empty.",
+            input_value=df,
+        )
 
-def validate_pixel_input_dimensions(df: pd.DataFrame) -> None:
     if df.shape[1] != 2:
         raise InvalidInputError(
-            message="Invalid input dimensions: expected 2 columns (u, v), got",
+            message="Invalid input dimensions: expected 2 columns (x, y), got",
             input_value=df.shape[1],
         )
+
     if sorted(df.columns) != sorted([HomogeneousCoordinate.X, HomogeneousCoordinate.Y]):
         raise InvalidInputError(
             message=f"Invalid column names: expected ['{HomogeneousCoordinate.X}', '{HomogeneousCoordinate.Y}'], got",