Braindecode 1.8.0.dev169208086__tar.gz → 1.8.0.dev170432067__tar.gz

{braindecode-1.8.0.dev169208086/braindecode.egg-info → braindecode-1.8.0.dev170432067}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.0.dev169208086
+Version: 1.8.0.dev170432067
 Summary: Deep learning software to decode EEG, ECG or MEG signals
 Author-email: Robin Tibor Schirrmeister <robintibor@gmail.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Alexandre Gramfort <agramfort@meta.com>
 Maintainer-email: Alexandre Gramfort <agramfort@meta.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Robin Tibor Schirrmeister <robintibor@gmail.com>
@@ -34,7 +34,6 @@ Requires-Dist: pandas
 Requires-Dist: wfdb>=4.3.1
 Requires-Dist: linear_attention_transformer
 Requires-Dist: docstring_inheritance
-Requires-Dist: rotary_embedding_torch
 Requires-Dist: pydantic>=2.0
 Provides-Extra: moabb
 Requires-Dist: moabb>=1.4.3; extra == "moabb"
@@ -51,6 +50,7 @@ Requires-Dist: pytest-cov; extra == "tests"
 Requires-Dist: codecov; extra == "tests"
 Requires-Dist: pytest_cases; extra == "tests"
 Requires-Dist: mypy; extra == "tests"
+Requires-Dist: ipython; extra == "tests"
 Requires-Dist: transformers>=4.57.0; extra == "tests"
 Requires-Dist: bids_validator; extra == "tests"
 Provides-Extra: typing

{braindecode-1.8.0.dev169208086 → braindecode-1.8.0.dev170432067}/braindecode/augmentation/base.py

@@ -3,6 +3,7 @@
 #          Bruno Aristimunha <b.aristimunha@gmail.com>
 #          Martin Wimpff <martin.wimpff@iss.uni-stuttgart.de>
 #          Valentin Iovene <val@too.gy>
+#          Sarthak Tayal <sarthaktayal2@gmail.com>
 # License: BSD (3-clause)
 
 from numbers import Real
@@ -176,6 +177,14 @@ class Compose(Transform):
         return X, y
 
 
+def _as_mixed_target(y, lam_dtype):
+    # an untouched target is the same as being mixed with itself with lam of one
+    if isinstance(y, (tuple, list)) and len(y) == 3:
+        return tuple(y)
+    lam = torch.ones(y.shape[0], device=y.device, dtype=lam_dtype)
+    return y, y, lam
+
+
 class _AugmentationCollate:
     """Collate that applies a transform to each batch, with optional expansion.
 
@@ -193,7 +202,10 @@ class _AugmentationCollate:
         ``0`` (default) applies the transform in place (batch size unchanged).
         ``> 0`` keeps the clean originals and appends ``n_augmentation``
         independently transformed copies, returning ``(X, y)`` of
-        ``(1 + n_augmentation)`` times the original size.
+        ``(1 + n_augmentation)`` times the original size. When the transform
+        mixes targets, as :class:`braindecode.augmentation.Mixup` does, ``y``
+        stays the ``(y_a, y_b, lam)`` triple and the clean originals get a
+        mixing coefficient of one.
     """
 
     def __init__(self, transform, device=None, n_augmentation=0):
@@ -216,6 +228,18 @@ class _AugmentationCollate:
             aug_X, aug_y = self.transform(X, y)
             xs.append(aug_X)
             ys.append(aug_y)
+        mixed_ys = [
+            aug_y
+            for aug_y in ys
+            if isinstance(aug_y, (tuple, list)) and len(aug_y) == 3
+        ]
+        if mixed_ys:
+            # a target-mixing transform such as Mixup returns (y_a, y_b, lam),
+            # so the parts are concatenated one by one and the untouched copies
+            # are given a mixing coefficient of one
+            lam_dtype = mixed_ys[0][2].dtype
+            ys = [_as_mixed_target(aug_y, lam_dtype) for aug_y in ys]
+            return torch.cat(xs), tuple(torch.cat(part) for part in zip(*ys))
         return torch.cat(xs), torch.cat(ys)
 
 

{braindecode-1.8.0.dev169208086 → braindecode-1.8.0.dev170432067}/braindecode/augmentation/functional.py

@@ -1065,13 +1065,11 @@ def mixup(
     batch_size, n_channels, n_times = X.shape
 
     X_mix = torch.zeros((batch_size, n_channels, n_times)).to(device)
-    y_a = torch.arange(batch_size).to(device)
-    y_b = torch.arange(batch_size).to(device)
+    y_a = y.clone()
+    y_b = y[idx_perm].clone()
 
     for idx in range(batch_size):
         X_mix[idx] = lam[idx] * X[idx] + (1 - lam[idx]) * X[idx_perm[idx]]
-        y_a[idx] = y[idx]
-        y_b[idx] = y[idx_perm[idx]]
 
     return X_mix, (y_a, y_b, lam)
 

{braindecode-1.8.0.dev169208086 → braindecode-1.8.0.dev170432067}/braindecode/augmentation/transforms.py

@@ -1068,16 +1068,18 @@ class Mixup(Transform):
         device = X.device
         batch_size, _, _ = X.shape
 
+        # lam follows the dtype of X, numpy draws float64 and that would leak
+        # into the mixed signal and into the loss returned by mixup_criterion
         if self.alpha > 0:
             if self.beta_per_sample:
                 lam = torch.as_tensor(
                     self.rng.beta(self.alpha, self.alpha, batch_size)
-                ).to(device)
+                ).to(device=device, dtype=X.dtype)
             else:
-                lam = torch.ones(batch_size).to(device)
+                lam = torch.ones(batch_size, dtype=X.dtype).to(device)
                 lam *= self.rng.beta(self.alpha, self.alpha)
         else:
-            lam = torch.ones(batch_size).to(device)
+            lam = torch.ones(batch_size, dtype=X.dtype).to(device)
 
         idx_perm = torch.as_tensor(
             self.rng.permutation(

{braindecode-1.8.0.dev169208086 → braindecode-1.8.0.dev170432067}/braindecode/classifier.py

@@ -228,8 +228,9 @@ class EEGClassifier(_EEGNeuralNet, NeuralNetClassifier):
             if return_targets:
                 return preds, X.get_metadata()["target"].to_numpy()
             return preds
+        self.check_is_fitted()
         return predict_trials(
-            module=self.module,
+            module=self.module_,
             dataset=X,
             return_targets=return_targets,
             batch_size=self.batch_size,

braindecode-1.8.0.dev170432067/braindecode/datasets/_notebook_viewer.py

@@ -0,0 +1,255 @@
+# Authors: Bruno Aristimunha <b.aristimunha@gmail.com>
+#
+# License: BSD (3-clause)
+"""Serverless in-notebook viewer for file-backed recordings.
+
+The bytes on disk behind a dataset element are inlined in the cell output
+as base64 and handed to the deployed eegdash-viewer over its ``postMessage``
+bridge (``docs/embedding.md`` in https://github.com/eegdash/eegdash-viewer):
+no server, no CORS. The output is an iframe plus an inline script, so it
+renders when the cell ran in your session or the saved notebook is trusted
+(``jupyter trust``).
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import uuid
+from pathlib import Path
+from urllib.parse import urlsplit
+
+import mne_bids
+from mne.utils import _soft_import
+
+CDN = "https://eegdash.github.io/eegdash-viewer"
+MAX_BYTES = 64 * 2**20  # base64 output per call; it is saved with the notebook
+EXTENSIONS = {
+    ".set",
+    ".edf",
+    ".bdf",
+    ".vhdr",
+    ".fif",
+    ".snirf",
+    ".nwb",
+}  # viewer readers
+_BIDS = {"eeg", "ieeg", "emg", "meg", "nirs"}
+_SIBLINGS = {".vhdr": (".eeg", ".vmrk"), ".set": (".fdt",)}  # travel with the header
+_HEADER = {s: h for h, ss in _SIBLINGS.items() for s in ss}  # data file -> header
+
+_SCRIPT = """<iframe id=%(id)s title="eegdash trace viewer" style="width:100%%;height:%(height)spx;
+border:1px solid var(--jp-border-color1,#d9dce1);border-radius:6px;background:transparent"></iframe>
+<script>
+(function () {
+  var self = document.currentScript, id = %(id)s;   // Lab re-runs scripts in place; VS Code/nbclassic elsewhere
+  var frame = (self && self.previousElementSibling && self.previousElementSibling.tagName === "IFRAME")
+    ? self.previousElementSibling : document.getElementById(id);
+  if (!frame) { console.error("eegdash viewer: output iframe " + id + " not found"); return; }
+  var payload = %(payload)s, origin = %(origin)s, files = null, pose = null;
+  function decode(b64) {
+    if (Uint8Array.fromBase64) return Uint8Array.fromBase64(b64);
+    var bin = atob(b64), out = new Uint8Array(bin.length);
+    for (var i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+    return out;
+  }
+  function send(target) {
+    try {
+      if (!files) {
+        files = payload.files.map(function (f) { return new File([decode(f.b64)], f.name); });
+        pose = payload.pose ? "data:application/json;base64," + payload.pose : null;
+        payload = null;
+      }
+      frame.contentWindow.postMessage({ type: "eegdash-viewer:open", files: files, pose: pose }, target || origin);
+    } catch (err) {
+      frame.insertAdjacentHTML("afterend", '<div style="font:12px system-ui;color:#b3261e">eegdash viewer: '
+        + String(err.message).replace(/</g, "&lt;") + "</div>");
+    }
+  }
+  window.addEventListener("message", function onMessage(e) {
+    if (e.source === frame.contentWindow && e.data && e.data.type === "eegdash-viewer:ready") send(e.origin);
+    else if (!frame.isConnected) window.removeEventListener("message", onMessage);
+  });
+  frame.src = %(src)s;   // after the listener, so "ready" can never precede it
+})();
+</script>"""
+
+
+def recording_files(recording: Path) -> tuple[list[Path], Path | None]:
+    """``(files, pose)`` to inline for a recording: the header first, then the
+    split-format siblings, the BIDS-inherited ``_channels.tsv``/``_events.tsv``
+    (``mne_bids`` parses the name; plain names get none) and, separately, the
+    ``<prefix>_desc-pose.json`` hand-pose sidecar next to it. Symlinks keep
+    their name (git-annex/datalad)."""
+    rec = Path(recording)
+    if not rec.exists():
+        raise ValueError(
+            f"{rec.name}: file not found (a datalad symlink may need `datalad get`)"
+        )
+    if (
+        rec.is_dir()
+        or rec.suffix.lower() not in EXTENSIONS
+        or rec.stem.endswith("_epo")
+    ):
+        raise ValueError(
+            f"{rec.name}: the viewer opens raw recordings in {' '.join(sorted(EXTENSIONS))}"
+        )
+    sidecars: list[Path | None] = []
+    try:
+        bids = mne_bids.get_bids_path_from_fname(rec, check=False)
+        if bids.subject is not None:  # hyphen-free names parse, but are not BIDS
+            sidecars = [
+                bids.find_matching_sidecar(
+                    suffix=s, extension=".tsv", on_error="ignore"
+                )
+                for s in ("channels", "events")
+            ]
+    except (
+        KeyError,
+        ValueError,
+    ):  # not a BIDS name / unknown entity somewhere in the tree
+        pass
+    files = [rec]
+    for p in [
+        rec.with_suffix(e) for e in _SIBLINGS.get(rec.suffix.lower(), ())
+    ] + sidecars:
+        if p and p.is_file():
+            if p not in files:
+                files.append(p)
+        elif p and p.is_symlink():  # dangling: git-annex/datalad content not fetched
+            raise ValueError(f"{p.name}: dangling symlink (try `datalad get`)")
+    stem, _, token = rec.stem.rpartition("_")
+    pose = rec.with_name((stem if token in _BIDS else rec.stem) + "_desc-pose.json")
+    return files, pose if pose.is_file() else None
+
+
+def build_viewer_html(
+    recording: Path,
+    *,
+    height: int = 520,
+    cdn_url: str = CDN,
+    max_bytes: int = MAX_BYTES,
+) -> str:
+    """Viewer iframe + inlined bytes + bridge script for one recording."""
+    url = urlsplit(cdn_url)
+    if (
+        url.scheme not in ("http", "https")
+        or not url.netloc
+        or url.username
+        or url.query
+        or url.fragment
+        or url.path.endswith(("index.html", "index.htm"))
+    ):
+        raise ValueError(
+            f"cdn_url must be the viewer's base http(s) URL, got {cdn_url!r}"
+        )
+    files, pose = recording_files(recording)
+    encoded = sum(
+        4 * -(-p.stat().st_size // 3) for p in files + ([pose] if pose else [])
+    )
+    if encoded > max_bytes:
+        raise ValueError(
+            f"{files[0].name}: {encoded / 2**20:.1f} MiB of base64 would be inlined into the "
+            f"notebook output (max_bytes={max_bytes / 2**20:.1f} MiB); crop/downsample or raise it"
+        )
+    rec = files[0]
+    # The viewer picks the recording by its *_<datatype>.<ext> name: plain names
+    # are posted as <stem>_eeg<ext>, an EEGLAB .fdt next to the posted .set name.
+    head = (
+        rec.name
+        if rec.stem.rpartition("_")[2] in _BIDS
+        else f"{rec.stem}_eeg{rec.suffix.lower()}"
+    )
+    names = [head] + [
+        head.rsplit("_", 1)[0] + "_eeg.fdt" if p.suffix.lower() == ".fdt" else p.name
+        for p in files[1:]
+    ]
+    b64 = [base64.b64encode(p.read_bytes()).decode() for p in files]
+    literals = {
+        "id": f"eegdash-viewer-{uuid.uuid4().hex[:8]}",
+        "height": int(height),
+        "payload": {
+            "files": [{"name": n, "b64": b} for n, b in zip(names, b64)],
+            "pose": base64.b64encode(pose.read_bytes()).decode() if pose else None,
+        },
+        "origin": f"{url.scheme}://{url.netloc}",
+        "src": f"{url.geturl().rstrip('/')}/index.html?embed=1",
+    }
+    return _SCRIPT % {
+        k: json.dumps(v).replace("<", "\\u003c") for k, v in literals.items()
+    }
+
+
+def _recording(dataset, index: int) -> Path:
+    """File behind ``dataset.datasets[index]``: the one its mne ``raw`` reads (a
+    data file maps back to its header; lazily downloading datasets fetch it when
+    ``raw`` is accessed) or the recorded ``description["path"]``."""
+    ds = dataset.datasets[index]
+    names = [
+        Path(f)
+        for f in getattr(getattr(ds, "raw", None), "filenames", None) or ()
+        if isinstance(f, (str, os.PathLike))
+    ]
+    if len(names) > 1:
+        raise ValueError(
+            f"{type(dataset).__name__}[{index}]: split recordings are not supported"
+        )
+    desc = getattr(ds, "description", None)  # dict or pandas Series
+    recorded = desc.get("path") if desc is not None else None
+    path = (
+        names[0]
+        if names
+        else Path(recorded)
+        if isinstance(recorded, (str, os.PathLike))
+        else None
+    )
+    if path is None:
+        raise ValueError(
+            f"{type(dataset).__name__}[{index}] is not backed by a recording file"
+        )
+    header = path.with_suffix(_HEADER.get(path.suffix.lower(), path.suffix))
+    return header if header.is_file() else path
+
+
+def plot(
+    dataset,
+    index: int = 0,
+    *,
+    height: int = 520,
+    cdn_url: str = CDN,
+    max_bytes: int = MAX_BYTES,
+):
+    """Show one recording in the eegdash-viewer inside a Jupyter cell.
+
+    Serverless: the recording bytes (as on disk) are inlined in the output and
+    pushed to the viewer at ``cdn_url`` over ``postMessage``; the output renders
+    when the cell ran in your session or the notebook is trusted. A
+    ``*_desc-pose.json`` sidecar next to the recording adds the synchronized
+    hand-pose panel. Needs IPython (soft dependency).
+
+    Parameters
+    ----------
+    index : int
+        Recording to display.
+    height : int
+        Viewer height in pixels.
+    cdn_url : str
+        Base URL of a deployed eegdash-viewer.
+    max_bytes : int
+        Refuse to inline more than this much base64 (default 64 MiB); the
+        payload is saved with the notebook and, like any cell output, stays
+        referenced by IPython's ``Out`` history for the session.
+
+    Returns
+    -------
+    IPython.display.HTML
+    """
+    ipython = _soft_import("IPython", purpose=f"{type(dataset).__name__}.plot()")
+    return ipython.display.HTML(
+        build_viewer_html(
+            _recording(dataset, index),
+            height=height,
+            cdn_url=cdn_url,
+            max_bytes=max_bytes,
+        )
+    )

{braindecode-1.8.0.dev169208086 → braindecode-1.8.0.dev170432067}/braindecode/datasets/base.py

@@ -32,6 +32,7 @@ from mne.utils.docs import deprecated
 from torch.utils.data import ConcatDataset, Dataset, IterableDataset
 from typing_extensions import TypeVar
 
+from ._notebook_viewer import plot as _viewer_plot
 from .bids.hub import HubDatasetMixin
 from .bids.hub_io import _restore_nan_from_json
 from .registry import register_dataset
@@ -59,6 +60,7 @@ def _html_row(label, value):
 
 _METADATA_INTERNAL_COLS = {
     "i_window_in_trial",
+    "i_trial_in_dataset",
     "i_start_in_trial",
     "i_stop_in_trial",
     "target",
@@ -1173,6 +1175,8 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
         If True, defer computing cumulative sizes until length or item access.
     """
 
+    plot = _viewer_plot  # eegdash-viewer embed; a direct member so the API docs list it
+
     datasets: list[T]
 
     def __init__(
@@ -1374,6 +1378,20 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
                 "datasets are WindowsDataset."
             )
 
+        for ds in self.datasets:
+            if hasattr(ds, "_windows") and ds._windows is not None:
+                df = ds._windows.metadata
+            else:
+                df = ds.metadata
+            if (
+                "i_trial_in_dataset" in df.columns
+                and "i_trial_in_dataset" in ds.description
+            ):
+                raise ValueError(
+                    "Dataset descriptions cannot contain the reserved window "
+                    "metadata key 'i_trial_in_dataset'."
+                )
+
         all_dfs = list()
         for ds in self.datasets:
             if hasattr(ds, "_windows") and ds._windows is not None:

{braindecode-1.8.0.dev169208086 → braindecode-1.8.0.dev170432067}/braindecode/datasets/bids/hub.py

@@ -28,6 +28,7 @@ The format follows a BIDS-inspired sourcedata structure:
 # License: BSD (3-clause)
 
 import contextlib
+import copy
 import json
 import logging
 import tempfile
@@ -56,6 +57,7 @@ from .hub_io import (
     _load_eegwindows_from_zarr,
     _load_raw_from_zarr,
     _load_windows_from_zarr,
+    _prepare_info_for_json,
     _save_eegwindows_to_zarr,
     _save_raw_to_zarr,
     _save_windows_to_zarr,
@@ -72,6 +74,33 @@ log = logging.getLogger(__name__)
 _LOCK_FILE = "format_info.json"
 
 
+def _normalize_kwargs_for_json(value, field_name):
+    """Return one preprocessing-kwargs value as native strict JSON."""
+
+    def _convert(obj):
+        if isinstance(obj, np.ndarray):
+            return _convert(obj.tolist())
+        if isinstance(obj, dict):
+            return {key: _convert(item) for key, item in obj.items()}
+        if isinstance(obj, (list, tuple)):
+            return [_convert(item) for item in obj]
+        if isinstance(obj, np.generic):
+            return _convert(obj.item())
+        return obj
+
+    try:
+        converted = _convert(value)
+        if isinstance(converted, str):
+            raise ValueError(
+                "a root string is ambiguous with the legacy encoded format"
+            )
+        return json.loads(json.dumps(converted, allow_nan=False))
+    except (OverflowError, RecursionError, TypeError, ValueError) as error:
+        raise ValueError(
+            f"{field_name} must contain only finite JSON-serializable values"
+        ) from error
+
+
 class HubDatasetMixin:
     """
     Mixin class for Hugging Face Hub integration with EEG datasets.
@@ -685,14 +714,57 @@ class HubDatasetMixin:
                 f"{output_path} already exists. Set overwrite=True to replace it."
             )
 
-        # Create zarr store (zarr v3 API)
-        root = zarr.open(str(output_path), mode="w")
-
         # Validate uniformity across all datasets using shared validation
         dataset_type, _, _ = hub_validation.validate_dataset_uniformity(self.datasets)
 
-        # Keep reference to first dataset for preprocessing kwargs
-        first_ds = self.datasets[0]
+        # Normalize every JSON value before opening the output store. The cached
+        # values below are the exact values handed to the write helpers.
+        prepared_infos = []
+        for ds in self.datasets:
+            if dataset_type == "WindowsDataset":
+                info = ds.windows.info
+            elif dataset_type in ("EEGWindowsDataset", "RawDataset"):
+                info = ds.raw.info
+            prepared_infos.append(_prepare_info_for_json(info.to_json_dict()))
+
+        prepared_kwargs = {}
+        for kwarg_name in [
+            "raw_preproc_kwargs",
+            "window_kwargs",
+            "window_preproc_kwargs",
+        ]:
+            expected_present = hasattr(self.datasets[0], kwarg_name)
+            expected_value = None
+            expected_token = None
+            for i_ds, ds in enumerate(self.datasets):
+                present = hasattr(ds, kwarg_name)
+                if present != expected_present:
+                    raise ValueError(
+                        f"{kwarg_name} on dataset {i_ds} has inconsistent presence; "
+                        "the Zarr format stores one global value"
+                    )
+                if not present:
+                    continue
+                value = _normalize_kwargs_for_json(
+                    getattr(ds, kwarg_name), f"{kwarg_name} on dataset {i_ds}"
+                )
+                value_token = json.dumps(
+                    value, sort_keys=True, separators=(",", ":"), allow_nan=False
+                )
+                if i_ds == 0:
+                    expected_value = value
+                    expected_token = value_token
+                elif value_token != expected_token:
+                    raise ValueError(
+                        f"{kwarg_name} on dataset {i_ds} differs from dataset 0; "
+                        "the Zarr format stores one global value"
+                    )
+            if expected_present:
+                prepared_kwargs[kwarg_name] = expected_value
+
+        # Create compressor and zarr store (zarr v3 API) only after preflight.
+        compressor = _create_compressor(compression, compression_level)
+        root = zarr.open(str(output_path), mode="w")
 
         # Store global metadata
         root.attrs["n_datasets"] = len(self.datasets)
@@ -706,21 +778,10 @@ class HubDatasetMixin:
         root.attrs["zarr_version"] = zarr.__version__
         root.attrs["scipy_version"] = scipy.__version__
 
-        # Save preprocessing kwargs (check first dataset, assuming uniform preprocessing)
-        # These are typically set by windowing functions on individual datasets
-        for kwarg_name in [
-            "raw_preproc_kwargs",
-            "window_kwargs",
-            "window_preproc_kwargs",
-        ]:
-            # Check first dataset for these attributes
-            if hasattr(first_ds, kwarg_name):
-                kwargs = getattr(first_ds, kwarg_name)
-                if kwargs:
-                    root.attrs[kwarg_name] = json.dumps(kwargs)
-
-        # Create compressor
-        compressor = _create_compressor(compression, compression_level)
+        # Save preprocessing kwargs from the preflight cache. These are
+        # typically set by windowing functions on individual datasets.
+        for kwarg_name, kwargs in prepared_kwargs.items():
+            root.attrs[kwarg_name] = kwargs
 
         # Save each recording
         for i_ds, ds in enumerate(self.datasets):
@@ -731,7 +792,7 @@ class HubDatasetMixin:
                 data = ds.windows.get_data()
                 metadata = ds.windows.metadata
                 description = ds.description
-                info_dict = ds.windows.info.to_json_dict()
+                info_dict = prepared_infos[i_ds]
                 target_name = ds.target_name if hasattr(ds, "target_name") else None
 
                 # Save using inlined function
@@ -750,7 +811,7 @@ class HubDatasetMixin:
                 raw = ds.raw
                 metadata = ds.metadata
                 description = ds.description
-                info_dict = ds.raw.info.to_json_dict()
+                info_dict = prepared_infos[i_ds]
                 targets_from = ds.targets_from
                 last_target_only = ds.last_target_only
 
@@ -771,7 +832,7 @@ class HubDatasetMixin:
                 # Get continuous raw data from RawDataset
                 raw = ds.raw
                 description = ds.description
-                info_dict = ds.raw.info.to_json_dict()
+                info_dict = prepared_infos[i_ds]
                 target_name = ds.target_name if hasattr(ds, "target_name") else None
 
                 # Save using inlined function
@@ -956,10 +1017,14 @@ class HubDatasetMixin:
             "window_preproc_kwargs",
         ]:
             if kwarg_name in root.attrs:
-                kwargs = json.loads(root.attrs[kwarg_name])
+                kwargs = root.attrs[kwarg_name]
+                if isinstance(kwargs, str):
+                    # Stores written by older braindecode versions kept
+                    # these attributes as double-encoded JSON strings.
+                    kwargs = json.loads(kwargs)
                 # Set on each individual dataset (where they were originally stored)
                 for ds in datasets:
-                    setattr(ds, kwarg_name, kwargs)
+                    setattr(ds, kwarg_name, copy.deepcopy(kwargs))
 
         return concat_ds