eegdash 0.0.8__py3-none-any.whl → 0.0.9__py3-none-any.whl

eegdash/data_config.py

@@ -0,0 +1,28 @@
+config = {
+  "required_fields": ["data_name"],
+  "attributes": {
+    "data_name": "str",
+    "dataset": "str",
+    "bidspath": "str",
+    "subject": "str",
+    "task": "str",
+    "session": "str",
+    "run": "str",
+    "sampling_frequency": "float",
+    "modality": "str",
+    "nchans": "int",
+    "ntimes": "int"
+  },
+  "description_fields": ["subject", "session", "run", "task", "age", "gender", "sex"],
+  "bids_dependencies_files": [
+    "dataset_description.json", 
+    "participants.tsv", 
+    "events.tsv", 
+    "events.json", 
+    "eeg.json", 
+    "electrodes.tsv", 
+    "channels.tsv", 
+    "coordsystem.json"
+  ],
+  "accepted_query_fields": ["data_name", "dataset"]
+}

eegdash/data_utils.py

@@ -17,6 +17,7 @@ import mne_bids
 from mne_bids import (
     BIDSPath,
 )
+from bids import BIDSLayout
 
 class EEGDashBaseDataset(BaseDataset):
     """Returns samples from an mne.io.Raw object along with a target.
@@ -96,7 +97,7 @@ class EEGDashBaseDataset(BaseDataset):
     
     def __len__(self):
         if self._raw is None:
-            return self.record['rawdatainfo']['ntimes']
+            return int(self.record['ntimes'] * self.record['sampling_frequency'])
         else:
             return len(self._raw)
 
@@ -216,39 +217,49 @@ class EEGDashBaseRaw(BaseRaw):
         _read_segments_file(self, data, idx, fi, start, stop, cals, mult, dtype="<f4")
 
 
-class BIDSDataset():
+class EEGBIDSDataset():
     ALLOWED_FILE_FORMAT = ['eeglab', 'brainvision', 'biosemi', 'european']
-    RAW_EXTENSION = {
-        'eeglab': '.set',
-        'brainvision': '.vhdr',
-        'biosemi': '.bdf',
-        'european': '.edf'
-    }
+    RAW_EXTENSIONS = {
+            '.set': ['.set', '.fdt'], # eeglab
+            '.edf': ['.edf'], # european
+            '.vhdr': ['.eeg', '.vhdr', '.vmrk', '.dat', '.raw'], # brainvision
+            '.bdf': ['.bdf'], # biosemi
+        }
     METADATA_FILE_EXTENSIONS = ['eeg.json', 'channels.tsv', 'electrodes.tsv', 'events.tsv', 'events.json']
     def __init__(self,
             data_dir=None,                            # location of bids dataset 
             dataset='',                               # dataset name
-            raw_format='eeglab',                      # format of raw data
         ):                            
         if data_dir is None or not os.path.exists(data_dir):
             raise ValueError('data_dir must be specified and must exist')
         self.bidsdir = Path(data_dir)
         self.dataset = dataset
         assert str(self.bidsdir).endswith(self.dataset)
-
-        if raw_format.lower() not in self.ALLOWED_FILE_FORMAT:
-            raise ValueError('raw_format must be one of {}'.format(self.ALLOWED_FILE_FORMAT))
-        self.raw_format = raw_format.lower()
-
-        # get all .set files in the bids directory
-        temp_dir = (Path().resolve() / 'data')
-        if not os.path.exists(temp_dir):
-            os.mkdir(temp_dir)
-        if not os.path.exists(temp_dir / f'{dataset}_files.npy'):
-            self.files = self.get_files_with_extension_parallel(self.bidsdir, extension=self.RAW_EXTENSION[self.raw_format])
-            np.save(temp_dir / f'{dataset}_files.npy', self.files)
-        else:
-            self.files = np.load(temp_dir / f'{dataset}_files.npy', allow_pickle=True)
+        self.layout = BIDSLayout(data_dir)
+
+        # get all recording files in the bids directory
+        self.files = self.get_recordings(self.layout)
+        assert len(self.files) > 0, ValueError('Unable to construct EEG dataset. No EEG recordings found.')
+        assert self.check_eeg_dataset(), ValueError('Dataset is not an EEG dataset.')
+        # temp_dir = (Path().resolve() / 'data')
+        # if not os.path.exists(temp_dir):
+        #     os.mkdir(temp_dir)
+        # if not os.path.exists(temp_dir / f'{dataset}_files.npy'):
+        #     self.files = self.get_files_with_extension_parallel(self.bidsdir, extension=self.RAW_EXTENSION[self.raw_format])
+        #     np.save(temp_dir / f'{dataset}_files.npy', self.files)
+        # else:
+        #     self.files = np.load(temp_dir / f'{dataset}_files.npy', allow_pickle=True)
+
+    def check_eeg_dataset(self):
+        return self.get_bids_file_attribute('modality', self.files[0]).lower() == 'eeg'
+
+    def get_recordings(self, layout:BIDSLayout):
+        files = []
+        for ext, exts in self.RAW_EXTENSIONS.items():
+            files = layout.get(extension=ext, return_type='filename')
+            if files:
+                break 
+        return files
 
     def get_relative_bidspath(self, filename):
         bids_parent_dir = self.bidsdir.parent
@@ -301,11 +312,6 @@ class BIDSDataset():
                     filepath = path / file
                     bids_files.append(filepath)
 
-                # cur_file_basename = file[:file.rfind('_')] # TODO: change to just search for any file with extension
-                # if file.endswith(extension) and cur_file_basename in basename:
-                #     filepath = path / file
-                #     bids_files.append(filepath)
-
         # check if file is in top level directory
         if any(file in os.listdir(path) for file in top_level_files):
             return bids_files
@@ -338,7 +344,7 @@ class BIDSDataset():
         
     def scan_directory(self, directory, extension):
         result_files = []
-        directory_to_ignore = ['.git']
+        directory_to_ignore = ['.git', '.datalad', 'derivatives', 'code']
         with os.scandir(directory) as entries:
             for entry in entries:
                 if entry.is_file() and entry.name.endswith(extension):
@@ -419,32 +425,22 @@ class BIDSDataset():
                 json_dict.update(json.load(f))
         return json_dict
 
-    def sfreq(self, data_filepath):
-        json_files = self.get_bids_metadata_files(data_filepath, 'eeg.json')
-        if len(json_files) == 0:
-            raise ValueError('No eeg.json found')
-
-        metadata = self.resolve_bids_json(json_files)
-        if 'SamplingFrequency' not in metadata:
-            raise ValueError('SamplingFrequency not found in metadata')
-        else:
-            return metadata['SamplingFrequency']
-    
-    def task(self, data_filepath):
-        return self.get_property_from_filename('task', data_filepath)
-        
-    def session(self, data_filepath):
-        return self.get_property_from_filename('session', data_filepath)
-
-    def run(self, data_filepath):
-        return self.get_property_from_filename('run', data_filepath)
-
-    def subject(self, data_filepath):
-        return self.get_property_from_filename('sub', data_filepath)
-
-    def num_channels(self, data_filepath):
-        channels_tsv = pd.read_csv(self.get_bids_metadata_files(data_filepath, 'channels.tsv')[0], sep='\t')
-        return len(channels_tsv)
+    def get_bids_file_attribute(self, attribute, data_filepath):
+        entities = self.layout.parse_file_entities(data_filepath)
+        bidsfile = self.layout.get(**entities)[0]
+        attributes = bidsfile.get_entities(metadata='all')
+        attribute_mapping = {
+            'sfreq': 'SamplingFrequency',
+            'modality': 'datatype',
+            'task': 'task',
+            'session': 'session',
+            'run': 'run',
+            'subject': 'subject',
+            'ntimes': 'RecordingDuration',
+            'nchans': 'EEGChannelCount'
+        }
+        attribute_value = attributes.get(attribute_mapping.get(attribute), None)
+        return attribute_value
 
     def channel_labels(self, data_filepath):
         channels_tsv = pd.read_csv(self.get_bids_metadata_files(data_filepath, 'channels.tsv')[0], sep='\t')
@@ -462,9 +458,12 @@ class BIDSDataset():
     def subject_participant_tsv(self, data_filepath):
         '''Get participants_tsv info of a subject based on filepath'''
         participants_tsv = pd.read_csv(self.get_bids_metadata_files(data_filepath, 'participants.tsv')[0], sep='\t')
+        # if participants_tsv is not empty
+        if participants_tsv.empty:
+            return {}
         # set 'participant_id' as index
         participants_tsv.set_index('participant_id', inplace=True)
-        subject = f'sub-{self.subject(data_filepath)}'
+        subject = f"sub-{self.get_bids_file_attribute('subject', data_filepath)}"
         return participants_tsv.loc[subject].to_dict()
     
     def eeg_json(self, data_filepath):

eegdash/features/__init__.py

@@ -0,0 +1,25 @@
+# Features datasets
+from .datasets import FeaturesDataset, FeaturesConcatDataset
+from .serialization import load_features_concat_dataset
+
+# Feature extraction
+from .extractors import (
+    FeatureExtractor,
+    FitableFeature,
+    UnivariateFeature,
+    BivariateFeature,
+    DirectedBivariateFeature,
+    MultivariateFeature,
+)
+from .decorators import (
+    FeaturePredecessor,
+    FeatureKind,
+    univariate_feature,
+    bivariate_feature,
+    directed_bivariate_feature,
+    multivariate_feature,
+)
+from .utils import extract_features, fit_feature_extractors
+
+# Features:
+from .feature_bank import *

eegdash/features/datasets.py

@@ -0,0 +1,453 @@
+from __future__ import annotations
+import os
+import json
+import shutil
+import warnings
+from typing import Dict, no_type_check
+from collections.abc import Callable, Iterable
+import numpy as np
+import pandas as pd
+from joblib import Parallel, delayed
+from braindecode.datasets.base import (
+    EEGWindowsDataset,
+    BaseConcatDataset,
+    _create_description,
+)
+
+
+class FeaturesDataset(EEGWindowsDataset):
+    """Returns samples from a pandas DataFrame object along with a target.
+
+    Dataset which serves samples from a pandas DataFrame object along with a
+    target. The target is unique for the dataset, and is obtained through the
+    `description` attribute.
+
+    Parameters
+    ----------
+    features : a pandas DataFrame
+        Tabular data.
+    description : dict | pandas.Series | None
+        Holds additional description about the continuous signal / subject.
+    transform : callable | None
+        On-the-fly transform applied to the example before it is returned.
+    """
+
+    def __init__(
+        self,
+        features: pd.DataFrame,
+        metadata: pd.DataFrame | None = None,
+        description: dict | pd.Series | None = None,
+        transform: Callable | None = None,
+        raw_info: Dict | None = None,
+        raw_preproc_kwargs: Dict | None = None,
+        window_kwargs: Dict | None = None,
+        window_preproc_kwargs: Dict | None = None,
+        features_kwargs: Dict | None = None,
+    ):
+        self.features = features
+        self.n_features = features.columns.size
+        self.metadata = metadata
+        self._description = _create_description(description)
+        self.transform = transform
+        self.raw_info = raw_info
+        self.raw_preproc_kwargs = raw_preproc_kwargs
+        self.window_kwargs = window_kwargs
+        self.window_preproc_kwargs = window_preproc_kwargs
+        self.features_kwargs = features_kwargs
+
+        self.crop_inds = metadata.loc[
+            :, ["i_window_in_trial", "i_start_in_trial", "i_stop_in_trial"]
+        ].to_numpy()
+        self.y = metadata.loc[:, "target"].to_list()
+
+    def __getitem__(self, index):
+        crop_inds = self.crop_inds[index].tolist()
+        X = self.features.iloc[index].to_numpy()
+        X = X.copy()
+        X.astype("float32")
+        if self.transform is not None:
+            X = self.transform(X)
+        y = self.y[index]
+        return X, y, crop_inds
+
+    def __len__(self):
+        return len(self.features.index)
+
+
+def _compute_stats(
+    ds: FeaturesDataset,
+    return_count=False,
+    return_mean=False,
+    return_var=False,
+    ddof=1,
+    numeric_only=False,
+):
+    res = []
+    if return_count:
+        res.append(ds.features.count(numeric_only=numeric_only))
+    if return_mean:
+        res.append(ds.features.mean(numeric_only=numeric_only))
+    if return_var:
+        res.append(ds.features.var(ddof=ddof, numeric_only=numeric_only))
+    return tuple(res)
+
+
+def _pooled_var(counts, means, variances, ddof):
+    count = counts.sum(axis=0)
+    mean = np.sum((counts / count) * means, axis=0)
+    var = np.sum(((counts - ddof) / (count - ddof)) * variances, axis=0)
+    var[:] += np.sum((counts / (count - ddof)) * (means**2), axis=0)
+    var[:] -= (count / (count - ddof)) * (mean**2)
+    var[:] = var.clip(min=0)
+    return count, mean, var
+
+
+class FeaturesConcatDataset(BaseConcatDataset):
+    """A base class for concatenated datasets.
+
+    Holds either mne.Raw or mne.Epoch in self.datasets and has
+    a pandas DataFrame with additional description.
+
+    Parameters
+    ----------
+    list_of_ds : list
+        list of BaseDataset, BaseConcatDataset or WindowsDataset
+    target_transform : callable | None
+        Optional function to call on targets before returning them.
+
+    """
+
+    def __init__(
+        self,
+        list_of_ds: list[FeaturesDataset] | None = None,
+        target_transform: Callable | None = None,
+    ):
+        # if we get a list of FeaturesConcatDataset, get all the individual datasets
+        if list_of_ds and isinstance(list_of_ds[0], FeaturesConcatDataset):
+            list_of_ds = [d for ds in list_of_ds for d in ds.datasets]
+        super().__init__(list_of_ds)
+
+        self.target_transform = target_transform
+
+    def split(
+        self,
+        by: str | list[int] | list[list[int]] | dict[str, list[int]],
+    ) -> dict[str, FeaturesConcatDataset]:
+        """Split the dataset based on information listed in its description.
+
+        The format could be based on a DataFrame or based on indices.
+
+        Parameters
+        ----------
+        by : str | list | dict
+            If ``by`` is a string, splitting is performed based on the
+            description DataFrame column with this name.
+            If ``by`` is a (list of) list of integers, the position in the first
+            list corresponds to the split id and the integers to the
+            datapoints of that split.
+            If a dict then each key will be used in the returned
+            splits dict and each value should be a list of int.
+
+        Returns
+        -------
+        splits : dict
+            A dictionary with the name of the split (a string) as key and the
+            dataset as value.
+        """
+        if isinstance(by, str):
+            split_ids = {
+                k: list(v) for k, v in self.description.groupby(by).groups.items()
+            }
+        elif isinstance(by, dict):
+            split_ids = by
+        else:
+            # assume list(int)
+            if not isinstance(by[0], list):
+                by = [by]
+            # assume list(list(int))
+            split_ids = {split_i: split for split_i, split in enumerate(by)}
+
+        return {
+            str(split_name): FeaturesConcatDataset(
+                [self.datasets[ds_ind] for ds_ind in ds_inds],
+                target_transform=self.target_transform,
+            )
+            for split_name, ds_inds in split_ids.items()
+        }
+
+    def get_metadata(self) -> pd.DataFrame:
+        """Concatenate the metadata and description of the wrapped Epochs.
+
+        Returns
+        -------
+        metadata : pd.DataFrame
+            DataFrame containing as many rows as there are windows in the
+            BaseConcatDataset, with the metadata and description information
+            for each window.
+        """
+        if not all([isinstance(ds, FeaturesDataset) for ds in self.datasets]):
+            raise TypeError(
+                "Metadata dataframe can only be computed when all "
+                "datasets are FeaturesDataset."
+            )
+
+        all_dfs = list()
+        for ds in self.datasets:
+            df = ds.metadata
+            for k, v in ds.description.items():
+                df[k] = v
+            all_dfs.append(df)
+
+        return pd.concat(all_dfs)
+
+    def save(self, path: str, overwrite: bool = False, offset: int = 0):
+        """Save datasets to files by creating one subdirectory for each dataset:
+        path/
+            0/
+                0-feat.parquet
+                metadata_df.pkl
+                description.json
+                raw-info.fif (if raw info was saved)
+                raw_preproc_kwargs.json (if raws were preprocessed)
+                window_kwargs.json (if this is a windowed dataset)
+                window_preproc_kwargs.json  (if windows were preprocessed)
+                features_kwargs.json
+            1/
+                1-feat.parquet
+                metadata_df.pkl
+                description.json
+                raw-info.fif (if raw info was saved)
+                raw_preproc_kwargs.json (if raws were preprocessed)
+                window_kwargs.json (if this is a windowed dataset)
+                window_preproc_kwargs.json  (if windows were preprocessed)
+                features_kwargs.json
+
+        Parameters
+        ----------
+        path : str
+            Directory in which subdirectories are created to store
+             -feat.parquet and .json files to.
+        overwrite : bool
+            Whether to delete old subdirectories that will be saved to in this
+            call.
+        offset : int
+            If provided, the integer is added to the id of the dataset in the
+            concat. This is useful in the setting of very large datasets, where
+            one dataset has to be processed and saved at a time to account for
+            its original position.
+        """
+        if len(self.datasets) == 0:
+            raise ValueError("Expect at least one dataset")
+        path_contents = os.listdir(path)
+        n_sub_dirs = len([os.path.isdir(e) for e in path_contents])
+        for i_ds, ds in enumerate(self.datasets):
+            # remove subdirectory from list of untouched files / subdirectories
+            if str(i_ds + offset) in path_contents:
+                path_contents.remove(str(i_ds + offset))
+            # save_dir/i_ds/
+            sub_dir = os.path.join(path, str(i_ds + offset))
+            if os.path.exists(sub_dir):
+                if overwrite:
+                    shutil.rmtree(sub_dir)
+                else:
+                    raise FileExistsError(
+                        f"Subdirectory {sub_dir} already exists. Please select"
+                        f" a different directory, set overwrite=True, or "
+                        f"resolve manually."
+                    )
+            # save_dir/{i_ds+offset}/
+            os.makedirs(sub_dir)
+            # save_dir/{i_ds+offset}/{i_ds+offset}-feat.parquet
+            self._save_features(sub_dir, ds, i_ds, offset)
+            # save_dir/{i_ds+offset}/metadata_df.pkl
+            self._save_metadata(sub_dir, ds)
+            # save_dir/{i_ds+offset}/description.json
+            self._save_description(sub_dir, ds.description)
+            # save_dir/{i_ds+offset}/raw-info.fif
+            self._save_raw_info(sub_dir, ds)
+            # save_dir/{i_ds+offset}/raw_preproc_kwargs.json
+            # save_dir/{i_ds+offset}/window_kwargs.json
+            # save_dir/{i_ds+offset}/window_preproc_kwargs.json
+            # save_dir/{i_ds+offset}/features_kwargs.json
+            self._save_kwargs(sub_dir, ds)
+        if overwrite:
+            # the following will be True for all datasets preprocessed and
+            # stored in parallel with braindecode.preprocessing.preprocess
+            if i_ds + 1 + offset < n_sub_dirs:
+                warnings.warn(
+                    f"The number of saved datasets ({i_ds + 1 + offset}) "
+                    f"does not match the number of existing "
+                    f"subdirectories ({n_sub_dirs}). You may now "
+                    f"encounter a mix of differently preprocessed "
+                    f"datasets!",
+                    UserWarning,
+                )
+        # if path contains files or directories that were not touched, raise
+        # warning
+        if path_contents:
+            warnings.warn(
+                f"Chosen directory {path} contains other "
+                f"subdirectories or files {path_contents}."
+            )
+
+    @staticmethod
+    def _save_features(sub_dir, ds, i_ds, offset):
+        parquet_file_name = f"{i_ds + offset}-feat.parquet"
+        parquet_file_path = os.path.join(sub_dir, parquet_file_name)
+        ds.features.to_parquet(parquet_file_path)
+
+    @staticmethod
+    def _save_raw_info(sub_dir, ds):
+        if hasattr(ds, "raw_info"):
+            fif_file_name = "raw-info.fif"
+            fif_file_path = os.path.join(sub_dir, fif_file_name)
+            ds.raw_info.save(fif_file_path)
+
+    @staticmethod
+    def _save_kwargs(sub_dir, ds):
+        for kwargs_name in [
+            "raw_preproc_kwargs",
+            "window_kwargs",
+            "window_preproc_kwargs",
+            "features_kwargs",
+        ]:
+            if hasattr(ds, kwargs_name):
+                kwargs_file_name = ".".join([kwargs_name, "json"])
+                kwargs_file_path = os.path.join(sub_dir, kwargs_file_name)
+                kwargs = getattr(ds, kwargs_name)
+                if kwargs is not None:
+                    with open(kwargs_file_path, "w") as f:
+                        json.dump(kwargs, f)
+
+    def to_dataframe(
+        self, include_metadata=False, include_target=False, include_crop_inds=False
+    ):
+        if include_metadata or (include_target and include_crop_inds):
+            dataframes = [
+                ds.metadata.join(ds.features, how="right", lsuffix="_metadata")
+                for ds in self.datasets
+            ]
+        elif include_target:
+            dataframes = [
+                ds.features.join(ds.metadata["target"], how="left", rsuffix="_metadata")
+                for ds in self.datasets
+            ]
+        elif include_crop_inds:
+            dataframes = [
+                ds.metadata.drop("target", axis="columns").join(
+                    ds.features, how="right", lsuffix="_metadata"
+                )
+                for ds in self.datasets
+            ]
+        else:
+            dataframes = [ds.features for ds in self.datasets]
+        return pd.concat(dataframes, axis=0, ignore_index=True)
+
+    def _numeric_columns(self):
+        return self.datasets[0].features.select_dtypes(include=np.number).columns
+
+    def count(self, numeric_only=False, n_jobs=1):
+        stats = Parallel(n_jobs)(
+            delayed(_compute_stats)(ds, return_count=True, numeric_only=numeric_only)
+            for ds in self.datasets
+        )
+        counts = np.array([s[0] for s in stats])
+        count = counts.sum(axis=0)
+        return pd.Series(count, index=self._numeric_columns())
+
+    def mean(self, numeric_only=False, n_jobs=1):
+        stats = Parallel(n_jobs)(
+            delayed(_compute_stats)(
+                ds, return_count=True, return_mean=True, numeric_only=numeric_only
+            )
+            for ds in self.datasets
+        )
+        counts, means = np.array([s[0] for s in stats]), np.array([s[1] for s in stats])
+        count = counts.sum(axis=0, keepdims=True)
+        mean = np.sum((counts / count) * means, axis=0)
+        return pd.Series(mean, index=self._numeric_columns())
+
+    def var(self, ddof=1, numeric_only=False, n_jobs=1):
+        stats = Parallel(n_jobs)(
+            delayed(_compute_stats)(
+                ds,
+                return_count=True,
+                return_mean=True,
+                return_var=True,
+                ddof=ddof,
+                numeric_only=numeric_only,
+            )
+            for ds in self.datasets
+        )
+        counts, means, variances = (
+            np.array([s[0] for s in stats]),
+            np.array([s[1] for s in stats]),
+            np.array([s[2] for s in stats]),
+        )
+        _, _, var = _pooled_var(counts, means, variances, ddof)
+        return pd.Series(var, index=self._numeric_columns())
+
+    def std(self, ddof=1, numeric_only=False, n_jobs=1):
+        return np.sqrt(self.var(ddof=ddof, numeric_only=numeric_only, n_jobs=n_jobs))
+
+    def zscore(self, ddof=1, numeric_only=False, eps=0, n_jobs=1):
+        stats = Parallel(n_jobs)(
+            delayed(_compute_stats)(
+                ds,
+                return_count=True,
+                return_mean=True,
+                return_var=True,
+                ddof=ddof,
+                numeric_only=numeric_only,
+            )
+            for ds in self.datasets
+        )
+        counts, means, variances = (
+            np.array([s[0] for s in stats]),
+            np.array([s[1] for s in stats]),
+            np.array([s[2] for s in stats]),
+        )
+        _, mean, var = _pooled_var(counts, means, variances, ddof)
+        std = np.sqrt(var) + eps
+        for ds in self.datasets:
+            ds.features = (ds.features - mean) / std
+
+    @staticmethod
+    def _enforce_inplace_operations(func_name, kwargs):
+        if "inplace" in kwargs and kwargs["inplace"] is False:
+            raise ValueError(
+                f"{func_name} only works inplace, please change "
+                + "to inplace=True (default)."
+            )
+        kwargs["inplace"] = True
+
+    def fillna(self, *args, **kwargs):
+        FeaturesConcatDataset._enforce_inplace_operations("fillna", kwargs)
+        for ds in self.datasets:
+            ds.features.fillna(*args, **kwargs)
+
+    def replace(self, *args, **kwargs):
+        FeaturesConcatDataset._enforce_inplace_operations("replace", kwargs)
+        for ds in self.datasets:
+            ds.features.replace(*args, **kwargs)
+
+    def interpolate(self, *args, **kwargs):
+        FeaturesConcatDataset._enforce_inplace_operations("interpolate", kwargs)
+        for ds in self.datasets:
+            ds.features.interpolate(*args, **kwargs)
+
+    def dropna(self, *args, **kwargs):
+        FeaturesConcatDataset._enforce_inplace_operations("dropna", kwargs)
+        for ds in self.datasets:
+            ds.features.dropna(*args, **kwargs)
+
+    def drop(self, *args, **kwargs):
+        FeaturesConcatDataset._enforce_inplace_operations("drop", kwargs)
+        for ds in self.datasets:
+            ds.features.drop(*args, **kwargs)
+
+    def join(self, concat_dataset: FeaturesConcatDataset, **kwargs):
+        assert len(self.datasets) == len(concat_dataset.datasets)
+        for ds1, ds2 in zip(self.datasets, concat_dataset.datasets):
+            assert len(ds1) == len(ds2)
+            ds1.features.join(ds2, **kwargs)