ezmsg-learn 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

ezmsg/learn/__version__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.1.0'
-__version_tuple__ = version_tuple = (1, 1, 0)
+__version__ = version = '1.2.0'
+__version_tuple__ = version_tuple = (1, 2, 0)
 
 __commit_id__ = commit_id = None

ezmsg/learn/process/adaptive_linear_regressor.py

@@ -11,7 +11,6 @@ from ezmsg.baseproc import (
     BaseAdaptiveTransformerUnit,
     processor_state,
 )
-from ezmsg.sigproc.sampler import SampleMessage
 from ezmsg.util.messages.axisarray import AxisArray, replace
 
 from ..util import AdaptiveLinearRegressor, RegressorType, get_regressor
@@ -78,30 +77,30 @@ class AdaptiveLinearRegressorTransformer(
         #  .template is updated in partial_fit
         pass
 
-    def partial_fit(self, message: SampleMessage) -> None:
-        if np.any(np.isnan(message.sample.data)):
+    def partial_fit(self, message: AxisArray) -> None:
+        if np.any(np.isnan(message.data)):
             return
 
         if self.settings.model_type in [
             AdaptiveLinearRegressor.LINEAR,
             AdaptiveLinearRegressor.LOGISTIC,
         ]:
-            x = pd.DataFrame.from_dict({k: v for k, v in zip(message.sample.axes["ch"].data, message.sample.data.T)})
+            x = pd.DataFrame.from_dict({k: v for k, v in zip(message.axes["ch"].data, message.data.T)})
             y = pd.Series(
-                data=message.trigger.value.data[:, 0],
-                name=message.trigger.value.axes["ch"].data[0],
+                data=message.attrs["trigger"].value.data[:, 0],
+                name=message.attrs["trigger"].value.axes["ch"].data[0],
             )
             self.state.model.learn_many(x, y)
         else:
-            X = message.sample.data
-            if message.sample.get_axis_idx("time") != 0:
-                X = np.moveaxis(X, message.sample.get_axis_idx("time"), 0)
-            self.state.model.partial_fit(X, message.trigger.value.data)
+            X = message.data
+            if message.get_axis_idx("time") != 0:
+                X = np.moveaxis(X, message.get_axis_idx("time"), 0)
+            self.state.model.partial_fit(X, message.attrs["trigger"].value.data)
 
         self.state.template = replace(
-            message.trigger.value,
-            data=np.empty_like(message.trigger.value.data),
-            key=message.trigger.value.key + "_pred",
+            message.attrs["trigger"].value,
+            data=np.empty_like(message.attrs["trigger"].value.data),
+            key=message.attrs["trigger"].value.key + "_pred",
         )
 
     def _process(self, message: AxisArray) -> AxisArray | None:

ezmsg/learn/process/linear_regressor.py

@@ -7,7 +7,6 @@ from ezmsg.baseproc import (
     BaseAdaptiveTransformerUnit,
     processor_state,
 )
-from ezmsg.sigproc.sampler import SampleMessage
 from ezmsg.util.messages.axisarray import AxisArray, replace
 from sklearn.linear_model._base import LinearModel
 
@@ -53,18 +52,18 @@ class LinearRegressorTransformer(
         #  .model and .template are initialized in __init__
         pass
 
-    def partial_fit(self, message: SampleMessage) -> None:
-        if np.any(np.isnan(message.sample.data)):
+    def partial_fit(self, message: AxisArray) -> None:
+        if np.any(np.isnan(message.data)):
             return
 
-        X = message.sample.data
-        y = message.trigger.value.data
+        X = message.data
+        y = message.attrs["trigger"].value.data
         # TODO: Resample should provide identical durations.
         self.state.model = self.state.model.fit(X[: y.shape[0]], y[: X.shape[0]])
         self.state.template = replace(
-            message.trigger.value,
+            message.attrs["trigger"].value,
             data=np.array([[]]),
-            key=message.trigger.value.key + "_pred",
+            key=message.attrs["trigger"].value.key + "_pred",
         )
 
     def _process(self, message: AxisArray) -> AxisArray:

ezmsg/learn/process/mlp_old.py

@@ -9,7 +9,6 @@ from ezmsg.baseproc import (
     BaseAdaptiveTransformerUnit,
     processor_state,
 )
-from ezmsg.sigproc.sampler import SampleMessage
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
@@ -134,14 +133,14 @@ class MLPProcessor(BaseAdaptiveTransformer[MLPSettings, AxisArray, AxisArray, ML
         dtype = torch.float32 if self.settings.single_precision else torch.float64
         return torch.tensor(data, dtype=dtype, device=self._state.device)
 
-    def partial_fit(self, message: SampleMessage) -> None:
+    def partial_fit(self, message: AxisArray) -> None:
         self._state.model.train()
 
         # TODO: loss_fn should be determined by setting
         loss_fn = torch.nn.functional.mse_loss
 
-        X = self._to_tensor(message.sample.data)
-        y_targ = self._to_tensor(message.trigger.value)
+        X = self._to_tensor(message.data)
+        y_targ = self._to_tensor(message.attrs["trigger"].value)
 
         with torch.set_grad_enabled(True):
             self._state.model.train()

ezmsg/learn/process/refit_kalman.py

@@ -8,7 +8,6 @@ from ezmsg.baseproc import (
     BaseAdaptiveTransformerUnit,
     processor_state,
 )
-from ezmsg.sigproc.sampler import SampleMessage
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
@@ -284,22 +283,22 @@ class RefitKalmanFilterProcessor(
             key=f"{message.key}_filtered" if hasattr(message, "key") else "filtered",
         )
 
-    def partial_fit(self, message: SampleMessage) -> None:
+    def partial_fit(self, message: AxisArray) -> None:
         """
         Perform refitting using externally provided data.
 
-        Expects message.sample.data (neural input) and message.trigger.value as a dict with:
+        Expects message.data (neural input) and message.attrs["trigger"].value as a dict with:
             - Y_state: (n_samples, n_states) array
             - intention_velocity_indices: Optional[int]
             - target_positions: Optional[np.ndarray]
             - cursor_positions: Optional[np.ndarray]
             - hold_flags: Optional[list[bool]]
         """
-        if not hasattr(message, "sample") or not hasattr(message, "trigger"):
+        if "trigger" not in message.attrs:
             raise ValueError("Invalid message format for partial_fit.")
 
-        X = np.array(message.sample.data)
-        values = message.trigger.value
+        X = np.array(message.data)
+        values = message.attrs["trigger"].value
 
         if not isinstance(values, dict) or "Y_state" not in values:
             raise ValueError("partial_fit expects trigger.value to include at least 'Y_state'.")

ezmsg/learn/process/rnn.py

@@ -5,7 +5,6 @@ import numpy as np
 import torch
 from ezmsg.baseproc import BaseAdaptiveTransformer, BaseAdaptiveTransformerUnit
 from ezmsg.baseproc.util.profile import profile_subpub
-from ezmsg.sigproc.sampler import SampleMessage
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
@@ -184,18 +183,18 @@ class RNNProcessor(
         if self._state.scheduler is not None:
             self._state.scheduler.step()
 
-    def partial_fit(self, message: SampleMessage) -> None:
+    def partial_fit(self, message: AxisArray) -> None:
         self._state.model.train()
 
-        X = self._to_tensor(message.sample.data)
+        X = self._to_tensor(message.data)
 
         # Add batch dimension if missing
         X, batched = self._ensure_batched(X)
 
         batch_size = X.shape[0]
-        preserve_state = self._maybe_reset_state(message.sample, batch_size)
+        preserve_state = self._maybe_reset_state(message, batch_size)
 
-        y_targ = message.trigger.value
+        y_targ = message.attrs["trigger"].value
         if not isinstance(y_targ, dict):
             y_targ = {"output": y_targ}
         y_targ = {key: self._to_tensor(value) for key, value in y_targ.items()}

ezmsg/learn/process/sgd.py

@@ -5,7 +5,6 @@ import numpy as np
 from ezmsg.baseproc import (
     BaseAdaptiveTransformer,
     BaseAdaptiveTransformerUnit,
-    SampleMessage,
     processor_state,
 )
 from ezmsg.util.messages.axisarray import AxisArray
@@ -87,23 +86,23 @@ class SGDDecoderTransformer(BaseAdaptiveTransformer[SGDDecoderSettings, AxisArra
             key=message.key,
         )
 
-    def partial_fit(self, message: SampleMessage) -> None:
+    def partial_fit(self, message: AxisArray) -> None:
         if self._hash != 0:
-            self._reset_state(message.sample)
+            self._reset_state(message)
             self._hash = 0
 
-        if np.any(np.isnan(message.sample.data)):
+        if np.any(np.isnan(message.data)):
             return
-        train_sample = message.sample.data.reshape(1, -1)
+        train_sample = message.data.reshape(1, -1)
         if self._state.b_first_train:
             self._state.model.partial_fit(
                 train_sample,
-                [message.trigger.value],
+                [message.attrs["trigger"].value],
                 classes=list(self.settings.label_weights.keys()),
             )
             self._state.b_first_train = False
         else:
-            self._state.model.partial_fit(train_sample, [message.trigger.value])
+            self._state.model.partial_fit(train_sample, [message.attrs["trigger"].value])
 
 
 class SGDDecoder(

ezmsg/learn/process/sklearn.py

@@ -10,7 +10,6 @@ from ezmsg.baseproc import (
     BaseAdaptiveTransformerUnit,
     processor_state,
 )
-from ezmsg.sigproc.sampler import SampleMessage
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
@@ -116,25 +115,25 @@ class SklearnModelProcessor(BaseAdaptiveTransformer[SklearnModelSettings, AxisAr
             # No checkpoint, initialize from scratch
             self._init_model()
 
-    def partial_fit(self, message: SampleMessage) -> None:
-        X = message.sample.data
-        y = message.trigger.value
+    def partial_fit(self, message: AxisArray) -> None:
+        X = message.data
+        y = message.attrs["trigger"].value
         if self._state.model is None:
-            self._reset_state(message.sample)
+            self._reset_state(message)
         if hasattr(self._state.model, "partial_fit"):
             kwargs = {}
             if self.settings.partial_fit_classes is not None:
                 kwargs["classes"] = self.settings.partial_fit_classes
             self._state.model.partial_fit(X, y, **kwargs)
         elif hasattr(self._state.model, "learn_many"):
-            df_X = pd.DataFrame({k: v for k, v in zip(message.sample.axes["ch"].data, message.sample.data.T)})
+            df_X = pd.DataFrame({k: v for k, v in zip(message.axes["ch"].data, message.data.T)})
             name = (
-                message.trigger.value.axes["ch"].data[0]
-                if hasattr(message.trigger.value, "axes") and "ch" in message.trigger.value.axes
+                message.attrs["trigger"].value.axes["ch"].data[0]
+                if hasattr(message.attrs["trigger"].value, "axes") and "ch" in message.attrs["trigger"].value.axes
                 else "target"
             )
             ser_y = pd.Series(
-                data=np.asarray(message.trigger.value.data).flatten(),
+                data=np.asarray(message.attrs["trigger"].value.data).flatten(),
                 name=name,
             )
             self._state.model.learn_many(df_X, ser_y)

ezmsg/learn/process/torch.py

@@ -12,7 +12,6 @@ from ezmsg.baseproc import (
     processor_state,
 )
 from ezmsg.baseproc.util.profile import profile_subpub
-from ezmsg.sigproc.sampler import SampleMessage
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
@@ -294,13 +293,13 @@ class TorchModelProcessor(
     def _process(self, message: AxisArray) -> list[AxisArray]:
         return self._common_process(message)
 
-    def partial_fit(self, message: SampleMessage) -> None:
+    def partial_fit(self, message: AxisArray) -> None:
         self._state.model.train()
 
-        X = self._to_tensor(message.sample.data)
+        X = self._to_tensor(message.data)
         X, batched = self._ensure_batched(X)
 
-        y_targ = message.trigger.value
+        y_targ = message.attrs["trigger"].value
         if not isinstance(y_targ, dict):
             y_targ = {"output": y_targ}
         y_targ = {key: self._to_tensor(value) for key, value in y_targ.items()}

ezmsg/learn/process/transformer.py

@@ -4,7 +4,6 @@ import ezmsg.core as ez
 import torch
 from ezmsg.baseproc import BaseAdaptiveTransformer, BaseAdaptiveTransformerUnit
 from ezmsg.baseproc.util.profile import profile_subpub
-from ezmsg.sigproc.sampler import SampleMessage
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
@@ -125,13 +124,13 @@ class TransformerProcessor(
                 )
             ]
 
-    def partial_fit(self, message: SampleMessage) -> None:
+    def partial_fit(self, message: AxisArray) -> None:
         self._state.model.train()
 
-        X = self._to_tensor(message.sample.data)
+        X = self._to_tensor(message.data)
         X, batched = self._ensure_batched(X)
 
-        y_targ = message.trigger.value
+        y_targ = message.attrs["trigger"].value
         if not isinstance(y_targ, dict):
             y_targ = {"output": y_targ}
         y_targ = {key: self._to_tensor(value) for key, value in y_targ.items()}

{ezmsg_learn-1.1.0.dist-info → ezmsg_learn-1.2.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: ezmsg-learn
-Version: 1.1.0
+Version: 1.2.0
 Summary: ezmsg namespace package for machine learning
 Author-email: Chadwick Boulay <chadwick.boulay@gmail.com>
 License-Expression: MIT
 License-File: LICENSE
 Requires-Python: >=3.10.15
-Requires-Dist: ezmsg-baseproc>=1.0.2
-Requires-Dist: ezmsg-sigproc>=2.14.0
+Requires-Dist: ezmsg-baseproc>=1.3.0
+Requires-Dist: ezmsg-sigproc>=2.15.0
 Requires-Dist: river>=0.22.0
 Requires-Dist: scikit-learn>=1.6.0
 Requires-Dist: torch>=2.6.0

{ezmsg_learn-1.1.0.dist-info → ezmsg_learn-1.2.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 ezmsg/learn/__init__.py,sha256=9vTW4C2EQCHgDAo8gIlGNDfOxcQpNGV3Cct9-HsBJKY,57
-ezmsg/learn/__version__.py,sha256=ePNVzJOkxR8FY5bezqKQ_fgBRbzH1G7QTaRDHvGQRAY,704
+ezmsg/learn/__version__.py,sha256=-uLONazCO1SzFfcY-K6A1keL--LIVfTYccGX6ciADac,704
 ezmsg/learn/util.py,sha256=cJPu07aWnsh_cIUMuVb0byXqm1CvLv9QO925U1t6oYs,2015
 ezmsg/learn/dim_reduce/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ezmsg/learn/dim_reduce/adaptive_decomp.py,sha256=SmxBuTATuo3DBrGkHiwC2BTg0rmiAF7kRMX_J8iObLM,9240
@@ -20,19 +20,19 @@ ezmsg/learn/model/transformer.py,sha256=Vfo_CATOmoNtaqkE4BRWJy6QcX-1J_Pz3rMG2ErQ
 ezmsg/learn/nlin_model/__init__.py,sha256=Ap62_lD7Dc3D-15ebhhBzT23PMrdyiV8fWV6eWy6wnE,101
 ezmsg/learn/nlin_model/mlp.py,sha256=l3KNCS7w9KlMiNVRxooqBb7Agl8A4OwnbZiJkWD2lJU,233
 ezmsg/learn/process/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ezmsg/learn/process/adaptive_linear_regressor.py,sha256=-TJsMJlcfIvwflSg4KXursseFb064cX9d-R65CLomJ0,5219
+ezmsg/learn/process/adaptive_linear_regressor.py,sha256=1xq4KN_UbTdrsbZ4PqSRs47aAVWMRLZNWJ5ZaRDtJ78,5179
 ezmsg/learn/process/base.py,sha256=1gfCMRh5JGRrKU-Obeh2abH1UW0dxHuc7kgxpBln76A,6655
-ezmsg/learn/process/linear_regressor.py,sha256=9cU25vXjVaClwBxR79M3qLi7sAKaEMAebwinITi5XYs,3071
-ezmsg/learn/process/mlp_old.py,sha256=5jw73VfUjHoY6kjVy22btyWeNhnYK19RpuzdXgxP324,6750
-ezmsg/learn/process/refit_kalman.py,sha256=nLQYWFbyP3BHrolvWbg-4HyRsaXs466nb9SU4-tMLEg,15148
-ezmsg/learn/process/rnn.py,sha256=5tYMe2EI71s95rTy-x-72s7tEKndcQsMvL-tf971HS8,9475
-ezmsg/learn/process/sgd.py,sha256=K3BgPLVszmTIeLiWi0uKq_loZCIy5XrSWKur3oRan98,3730
-ezmsg/learn/process/sklearn.py,sha256=Id8km2_8goHuErEtWLpFxqrrSNLpISZ6pGEPaNQ84yY,9486
+ezmsg/learn/process/linear_regressor.py,sha256=8gacrdJJ78U3gBgC62qxvDpZOamZW0kn9NJoRgoLJHc,3032
+ezmsg/learn/process/mlp_old.py,sha256=a2iS45ZlIfonPanerpKROSugYKPghas4JTErO7TM4RU,6700
+ezmsg/learn/process/refit_kalman.py,sha256=wrVHb2ZHIDLT0LVlZsNfsD5rdl8dBECxZnqvxDiJuyE,15065
+ezmsg/learn/process/rnn.py,sha256=HDc4PgZLTEtUVWGFUDqX9qA31Fid37Qj4eYR7jX7aUU,9418
+ezmsg/learn/process/sgd.py,sha256=vkPWDiBKXNhF0EjHbpJt9SskSKw4TRAbhE7uHOYh1Ik,3704
+ezmsg/learn/process/sklearn.py,sha256=Smpo2YITfjs8thVjSQ7kkqRjjSMa2FOL2ArW-fKMn38,9451
 ezmsg/learn/process/slda.py,sha256=BtVKBYkggvlC8_rLkrWfqthOFkKKFv-r9CdX_jWRn2o,4315
 ezmsg/learn/process/ssr.py,sha256=XiHcUSJ3tY3_HvATcQp427KhQIAZ9aVNvewCp-ODO8c,13939
-ezmsg/learn/process/torch.py,sha256=wvmeXmVzTPW5lEVf8bU4iu2gWg1mGuO0F6TIEEmNtP4,13126
-ezmsg/learn/process/transformer.py,sha256=e9XQFfpduDCUDJAwJ0ottQ9N2eZo-LC8firQlpuKheY,7760
-ezmsg_learn-1.1.0.dist-info/METADATA,sha256=dzHQzlVQahT_LEcZr3MZBcXBrVohxVSUJCG9F09ikHg,1494
-ezmsg_learn-1.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-ezmsg_learn-1.1.0.dist-info/licenses/LICENSE,sha256=BDD8rfac1Ur7mp0_3izEdr6fHgSA3Or6U1Kb0ZAWsow,1066
-ezmsg_learn-1.1.0.dist-info/RECORD,,
+ezmsg/learn/process/torch.py,sha256=HnFaUhimXM_ki2clcYDPN8wmwA1fpz_HEdcd_XhM4YM,13076
+ezmsg/learn/process/transformer.py,sha256=bnVi87xv95O3plNJVBN5W6pukuS0lKkTvJ7lqkpED9o,7710
+ezmsg_learn-1.2.0.dist-info/METADATA,sha256=v-okrlHbna_orkyBQ7xzzL1jpFgxH-AdhLf4FZ8GNhc,1494
+ezmsg_learn-1.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ezmsg_learn-1.2.0.dist-info/licenses/LICENSE,sha256=BDD8rfac1Ur7mp0_3izEdr6fHgSA3Or6U1Kb0ZAWsow,1066
+ezmsg_learn-1.2.0.dist-info/RECORD,,