accusleepy 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

accusleepy/classification.py

@@ -11,6 +11,7 @@ from tqdm import trange
 
 import accusleepy.constants as c
 from accusleepy.brain_state_set import BrainStateSet
+from accusleepy.fileio import EMGFilter, Hyperparameters
 from accusleepy.models import SSANN
 from accusleepy.signal_processing import (
     create_eeg_emg_image,
@@ -19,11 +20,6 @@ from accusleepy.signal_processing import (
     mixture_z_score_img,
 )
 
-BATCH_SIZE = 64
-LEARNING_RATE = 1e-3
-MOMENTUM = 0.9
-TRAINING_EPOCHS = 6
-
 
 class AccuSleepImageDataset(Dataset):
     """Dataset for loading AccuSleep training images"""
@@ -62,12 +58,16 @@ def get_device():
 
 
 def create_dataloader(
-    annotations_file: str, img_dir: str, shuffle: bool = True
+    annotations_file: str,
+    img_dir: str,
+    hyperparameters: Hyperparameters,
+    shuffle: bool = True,
 ) -> DataLoader:
     """Create DataLoader for a dataset of training or calibration images
 
     :param annotations_file: file with information on each training image
     :param img_dir: training image location
+    :param hyperparameters: model training hyperparameters
     :param shuffle: reshuffle data for every epoch
     :return: DataLoader for the data
 
@@ -76,7 +76,9 @@ def create_dataloader(
         annotations_file=annotations_file,
         img_dir=img_dir,
     )
-    return DataLoader(image_dataset, batch_size=BATCH_SIZE, shuffle=shuffle)
+    return DataLoader(
+        image_dataset, batch_size=hyperparameters.batch_size, shuffle=shuffle
+    )
 
 
 def train_ssann(
@@ -84,6 +86,7 @@ def train_ssann(
     img_dir: str,
     mixture_weights: np.array,
     n_classes: int,
+    hyperparameters: Hyperparameters,
 ) -> SSANN:
     """Train a SSANN classification model for sleep scoring
 
@@ -91,10 +94,13 @@ def train_ssann(
     :param img_dir: training image location
     :param mixture_weights: typical relative frequencies of brain states
     :param n_classes: number of classes the model will learn
+    :param hyperparameters: model training hyperparameters
     :return: trained Sleep Scoring Artificial Neural Network model
     """
     train_dataloader = create_dataloader(
-        annotations_file=annotations_file, img_dir=img_dir
+        annotations_file=annotations_file,
+        img_dir=img_dir,
+        hyperparameters=hyperparameters,
     )
 
     device = get_device()
@@ -106,9 +112,13 @@ def train_ssann(
     weight = torch.tensor((mixture_weights**-1).astype("float32")).to(device)
 
     criterion = nn.CrossEntropyLoss(weight=weight)
-    optimizer = optim.SGD(model.parameters(), lr=LEARNING_RATE, momentum=MOMENTUM)
+    optimizer = optim.SGD(
+        model.parameters(),
+        lr=hyperparameters.learning_rate,
+        momentum=hyperparameters.momentum,
+    )
 
-    for _ in trange(TRAINING_EPOCHS):
+    for _ in trange(hyperparameters.training_epochs):
         for data in train_dataloader:
             inputs, labels = data
             (inputs, labels) = (inputs.to(device), labels.to(device))
@@ -131,6 +141,7 @@ def score_recording(
     epoch_length: int | float,
     epochs_per_img: int,
     brain_state_set: BrainStateSet,
+    emg_filter: EMGFilter,
 ) -> np.array:
     """Use classification model to get brain state labels for a recording
 
@@ -146,6 +157,7 @@ def score_recording(
     :param epoch_length: epoch length, in seconds
     :param epochs_per_img: number of epochs for the model to consider
     :param brain_state_set: set of brain state options
+    :param emg_filter: EMG filter parameters
     :return: brain state labels, confidence scores
     """
     # prepare model
@@ -154,7 +166,7 @@ def score_recording(
     model.eval()
 
     # create and scale eeg+emg spectrogram
-    img = create_eeg_emg_image(eeg, emg, sampling_rate, epoch_length)
+    img = create_eeg_emg_image(eeg, emg, sampling_rate, epoch_length, emg_filter)
     img = mixture_z_score_img(
         img,
         mixture_means=mixture_means,
@@ -192,6 +204,7 @@ def example_real_time_scoring_function(
     epoch_length: int | float,
     epochs_per_img: int,
     brain_state_set: BrainStateSet,
+    emg_filter: EMGFilter,
 ) -> int:
     """Example function that could be used for real-time scoring
 
@@ -220,6 +233,7 @@ def example_real_time_scoring_function(
     :param epoch_length: epoch length, in seconds
     :param epochs_per_img: number of epochs shown to the model at once
     :param brain_state_set: set of brain state options
+    :param emg_filter: EMG filter parameters
     :return: brain state label
     """
     # prepare model
@@ -229,7 +243,7 @@ def example_real_time_scoring_function(
     model.eval()
 
     # create and scale eeg+emg spectrogram
-    img = create_eeg_emg_image(eeg, emg, sampling_rate, epoch_length)
+    img = create_eeg_emg_image(eeg, emg, sampling_rate, epoch_length, emg_filter)
     img = mixture_z_score_img(
         img,
         mixture_means=mixture_means,
@@ -260,6 +274,7 @@ def create_calibration_file(
     sampling_rate: int | float,
     epoch_length: int | float,
     brain_state_set: BrainStateSet,
+    emg_filter: EMGFilter,
 ) -> None:
     """Create file of calibration data for a subject
 
@@ -273,8 +288,9 @@ def create_calibration_file(
     :param sampling_rate: sampling rate, in Hz
     :param epoch_length: epoch length, in seconds
     :param brain_state_set: set of brain state options
+    :param emg_filter: EMG filter parameters
     """
-    img = create_eeg_emg_image(eeg, emg, sampling_rate, epoch_length)
+    img = create_eeg_emg_image(eeg, emg, sampling_rate, epoch_length, emg_filter)
     mixture_means, mixture_sds = get_mixture_values(
         img=img,
         labels=brain_state_set.convert_digit_to_class(labels),

accusleepy/config.json

@@ -20,5 +20,18 @@
         }
     ],
     "default_epoch_length": 2.5,
-    "save_confidence_setting": true
+    "default_overwrite_setting": false,
+    "save_confidence_setting": true,
+    "default_min_bout_length": 5.0,
+    "emg_filter": {
+        "order": 8,
+        "bp_lower": 20.0,
+        "bp_upper": 50.0
+    },
+    "hyperparameters": {
+        "batch_size": 64,
+        "learning_rate": 0.001,
+        "momentum": 0.9,
+        "training_epochs": 6
+    }
 }

accusleepy/constants.py

@@ -36,11 +36,33 @@ LABEL_COL = "label"
 # recording list file header:
 RECORDING_LIST_NAME = "recording_list"
 RECORDING_LIST_FILE_TYPE = ".json"
-# key for default epoch length in config
-DEFAULT_EPOCH_LENGTH_KEY = "default_epoch_length"
-# key used for default confidence score behavior in config
-DEFAULT_CONFIDENCE_SETTING_KEY = "save_confidence_setting"
 # filename used to store info about training image datasets
 ANNOTATIONS_FILENAME = "annotations.csv"
 # filename for annotation file for the calibration set
 CALIBRATION_ANNOTATION_FILENAME = "calibration_set.csv"
+
+# config file keys
+# ui setting keys
+DEFAULT_EPOCH_LENGTH_KEY = "default_epoch_length"
+DEFAULT_CONFIDENCE_SETTING_KEY = "save_confidence_setting"
+DEFAULT_MIN_BOUT_LENGTH_KEY = "default_min_bout_length"
+DEFAULT_OVERWRITE_KEY = "default_overwrite_setting"
+# EMG filter parameters key
+EMG_FILTER_KEY = "emg_filter"
+# model training hyperparameters key
+HYPERPARAMETERS_KEY = "hyperparameters"
+
+# default values
+# default UI settings
+DEFAULT_MIN_BOUT_LENGTH = 5.0
+DEFAULT_CONFIDENCE_SETTING = True
+DEFAULT_OVERWRITE_SETTING = False
+# default EMG filter parameters (order, bandpass frequencies)
+DEFAULT_EMG_FILTER_ORDER = 8
+DEFAULT_EMG_BP_LOWER = 20
+DEFAULT_EMG_BP_UPPER = 50
+# default hyperparameters
+DEFAULT_BATCH_SIZE = 64
+DEFAULT_LEARNING_RATE = 1e-3
+DEFAULT_MOMENTUM = 0.9
+DEFAULT_TRAINING_EPOCHS = 6

accusleepy/fileio.py

@@ -7,19 +7,26 @@ import pandas as pd
 from PySide6.QtWidgets import QListWidgetItem
 
 from accusleepy.brain_state_set import BRAIN_STATES_KEY, BrainState, BrainStateSet
-from accusleepy.constants import (
-    BRAIN_STATE_COL,
-    CONFIDENCE_SCORE_COL,
-    CONFIG_FILE,
-    DEFAULT_CONFIDENCE_SETTING_KEY,
-    DEFAULT_EPOCH_LENGTH_KEY,
-    EEG_COL,
-    EMG_COL,
-    MIXTURE_MEAN_COL,
-    MIXTURE_SD_COL,
-    RECORDING_LIST_NAME,
-    UNDEFINED_LABEL,
-)
+import accusleepy.constants as c
+
+
+@dataclass
+class EMGFilter:
+    """Convenience class for a EMG filter parameters"""
+
+    order: int  # filter order
+    bp_lower: int | float  # lower bandpass frequency
+    bp_upper: int | float  # upper bandpass frequency
+
+
+@dataclass
+class Hyperparameters:
+    """Convenience class for model training hyperparameters"""
+
+    batch_size: int
+    learning_rate: float
+    momentum: float
+    training_epochs: int
 
 
 @dataclass
@@ -41,8 +48,8 @@ def load_calibration_file(filename: str) -> (np.array, np.array):
     :return: mixture means and SDs
     """
     df = pd.read_csv(filename)
-    mixture_means = df[MIXTURE_MEAN_COL].values
-    mixture_sds = df[MIXTURE_SD_COL].values
+    mixture_means = df[c.MIXTURE_MEAN_COL].values
+    mixture_sds = df[c.MIXTURE_SD_COL].values
     return mixture_means, mixture_sds
 
 
@@ -69,8 +76,8 @@ def load_recording(filename: str) -> (np.array, np.array):
     :return: arrays of EEG and EMG data
     """
     df = load_csv_or_parquet(filename)
-    eeg = df[EEG_COL].values
-    emg = df[EMG_COL].values
+    eeg = df[c.EEG_COL].values
+    emg = df[c.EMG_COL].values
     return eeg, emg
 
 
@@ -81,10 +88,10 @@ def load_labels(filename: str) -> (np.array, np.array):
     :return: array of brain state labels and, optionally, array of confidence scores
     """
     df = load_csv_or_parquet(filename)
-    if CONFIDENCE_SCORE_COL in df.columns:
-        return df[BRAIN_STATE_COL].values, df[CONFIDENCE_SCORE_COL].values
+    if c.CONFIDENCE_SCORE_COL in df.columns:
+        return df[c.BRAIN_STATE_COL].values, df[c.CONFIDENCE_SCORE_COL].values
     else:
-        return df[BRAIN_STATE_COL].values, None
+        return df[c.BRAIN_STATE_COL].values, None
 
 
 def save_labels(
@@ -98,48 +105,92 @@ def save_labels(
     """
     if confidence_scores is not None:
         pd.DataFrame(
-            {BRAIN_STATE_COL: labels, CONFIDENCE_SCORE_COL: confidence_scores}
+            {c.BRAIN_STATE_COL: labels, c.CONFIDENCE_SCORE_COL: confidence_scores}
         ).to_csv(filename, index=False)
     else:
-        pd.DataFrame({BRAIN_STATE_COL: labels}).to_csv(filename, index=False)
+        pd.DataFrame({c.BRAIN_STATE_COL: labels}).to_csv(filename, index=False)
 
 
-def load_config() -> tuple[BrainStateSet, int | float, bool]:
+def load_config() -> tuple[
+    BrainStateSet, int | float, bool, bool, int | float, EMGFilter, Hyperparameters
+]:
     """Load configuration file with brain state options
 
-    :return: set of brain state options, other settings
+    :return: set of brain state options,
+        default epoch length,
+        default overwrite setting,
+        default confidence score output setting,
+        default minimum bout length,
+        EMG filter parameters,
+        model training hyperparameters
     """
     with open(
-        os.path.join(os.path.dirname(os.path.abspath(__file__)), CONFIG_FILE), "r"
+        os.path.join(os.path.dirname(os.path.abspath(__file__)), c.CONFIG_FILE), "r"
     ) as f:
         data = json.load(f)
 
     return (
         BrainStateSet(
-            [BrainState(**b) for b in data[BRAIN_STATES_KEY]], UNDEFINED_LABEL
+            [BrainState(**b) for b in data[BRAIN_STATES_KEY]], c.UNDEFINED_LABEL
+        ),
+        data[c.DEFAULT_EPOCH_LENGTH_KEY],
+        data.get(c.DEFAULT_OVERWRITE_KEY, c.DEFAULT_OVERWRITE_SETTING),
+        data.get(c.DEFAULT_CONFIDENCE_SETTING_KEY, c.DEFAULT_CONFIDENCE_SETTING),
+        data.get(c.DEFAULT_MIN_BOUT_LENGTH_KEY, c.DEFAULT_MIN_BOUT_LENGTH),
+        EMGFilter(
+            **data.get(
+                c.EMG_FILTER_KEY,
+                {
+                    "order": c.DEFAULT_EMG_FILTER_ORDER,
+                    "bp_lower": c.DEFAULT_EMG_BP_LOWER,
+                    "bp_upper": c.DEFAULT_EMG_BP_UPPER,
+                },
+            )
+        ),
+        Hyperparameters(
+            **data.get(
+                c.HYPERPARAMETERS_KEY,
+                {
+                    "batch_size": c.DEFAULT_BATCH_SIZE,
+                    "learning_rate": c.DEFAULT_LEARNING_RATE,
+                    "momentum": c.DEFAULT_MOMENTUM,
+                    "training_epochs": c.DEFAULT_TRAINING_EPOCHS,
+                },
+            )
         ),
-        data[DEFAULT_EPOCH_LENGTH_KEY],
-        data.get(DEFAULT_CONFIDENCE_SETTING_KEY, True),
     )
 
 
 def save_config(
     brain_state_set: BrainStateSet,
     default_epoch_length: int | float,
+    overwrite_setting: bool,
     save_confidence_setting: bool,
+    min_bout_length: int | float,
+    emg_filter: EMGFilter,
+    hyperparameters: Hyperparameters,
 ) -> None:
     """Save configuration of brain state options to json file
 
     :param brain_state_set: set of brain state options
-    :param default_epoch_length: epoch length to use when the GUI starts
-    :param save_confidence_setting: whether the option to save confidence
-        scores should be True by default
+    :param default_epoch_length: default epoch length
+    :param save_confidence_setting: default setting for
+        saving confidence scores
+    :param emg_filter: EMG filter parameters
+    :param min_bout_length: default minimum bout length
+    :param overwrite_setting: default setting for overwriting
+        existing labels
+    :param hyperparameters: model training hyperparameters
     """
     output_dict = brain_state_set.to_output_dict()
-    output_dict.update({DEFAULT_EPOCH_LENGTH_KEY: default_epoch_length})
-    output_dict.update({DEFAULT_CONFIDENCE_SETTING_KEY: save_confidence_setting})
+    output_dict.update({c.DEFAULT_EPOCH_LENGTH_KEY: default_epoch_length})
+    output_dict.update({c.DEFAULT_OVERWRITE_KEY: overwrite_setting})
+    output_dict.update({c.DEFAULT_CONFIDENCE_SETTING_KEY: save_confidence_setting})
+    output_dict.update({c.DEFAULT_MIN_BOUT_LENGTH_KEY: min_bout_length})
+    output_dict.update({c.EMG_FILTER_KEY: emg_filter.__dict__})
+    output_dict.update({c.HYPERPARAMETERS_KEY: hyperparameters.__dict__})
     with open(
-        os.path.join(os.path.dirname(os.path.abspath(__file__)), CONFIG_FILE), "w"
+        os.path.join(os.path.dirname(os.path.abspath(__file__)), c.CONFIG_FILE), "w"
     ) as f:
         json.dump(output_dict, f, indent=4)
 
@@ -152,7 +203,7 @@ def load_recording_list(filename: str) -> list[Recording]:
     """
     with open(filename, "r") as f:
         data = json.load(f)
-    recording_list = [Recording(**r) for r in data[RECORDING_LIST_NAME]]
+    recording_list = [Recording(**r) for r in data[c.RECORDING_LIST_NAME]]
     for i, r in enumerate(recording_list):
         r.name = i + 1
     return recording_list
@@ -165,7 +216,7 @@ def save_recording_list(filename: str, recordings: list[Recording]) -> None:
     :param recordings: list of recordings to export
     """
     recording_dict = {
-        RECORDING_LIST_NAME: [
+        c.RECORDING_LIST_NAME: [
             {
                 "recording_file": r.recording_file,
                 "label_file": r.label_file,

accusleepy/gui/main.py

@@ -39,6 +39,13 @@ from accusleepy.constants import (
     CALIBRATION_ANNOTATION_FILENAME,
     CALIBRATION_FILE_TYPE,
     DEFAULT_MODEL_TYPE,
+    DEFAULT_EMG_FILTER_ORDER,
+    DEFAULT_EMG_BP_LOWER,
+    DEFAULT_EMG_BP_UPPER,
+    DEFAULT_BATCH_SIZE,
+    DEFAULT_LEARNING_RATE,
+    DEFAULT_MOMENTUM,
+    DEFAULT_TRAINING_EPOCHS,
     LABEL_FILE_TYPE,
     MODEL_FILE_TYPE,
     REAL_TIME_MODEL_TYPE,
@@ -56,6 +63,8 @@ from accusleepy.fileio import (
     save_config,
     save_labels,
     save_recording_list,
+    EMGFilter,
+    Hyperparameters,
 )
 from accusleepy.gui.manual_scoring import ManualScoringWindow
 from accusleepy.gui.primary_window import Ui_PrimaryWindow
@@ -97,19 +106,25 @@ class AccuSleepWindow(QMainWindow):
         self.setWindowTitle("AccuSleePy")
 
         # fill in settings tab
-        self.brain_state_set, self.epoch_length, self.save_confidence_setting = (
-            load_config()
-        )
+        (
+            self.brain_state_set,
+            self.epoch_length,
+            self.only_overwrite_undefined,
+            self.save_confidence_scores,
+            self.min_bout_length,
+            self.emg_filter,
+            self.hyperparameters,
+        ) = load_config()
+
         self.settings_widgets = None
         self.initialize_settings_tab()
 
         # initialize info about the recordings, classification data / settings
         self.ui.epoch_length_input.setValue(self.epoch_length)
-        self.ui.save_confidence_checkbox.setChecked(self.save_confidence_setting)
+        self.ui.overwritecheckbox.setChecked(self.only_overwrite_undefined)
+        self.ui.save_confidence_checkbox.setChecked(self.save_confidence_scores)
+        self.ui.bout_length_input.setValue(self.min_bout_length)
         self.model = None
-        self.only_overwrite_undefined = False
-        self.save_confidence_scores = self.save_confidence_setting
-        self.min_bout_length = 5
 
         # initialize model training variables
         self.training_epochs_per_img = 9
@@ -186,6 +201,10 @@ class AccuSleepWindow(QMainWindow):
         self.ui.export_button.clicked.connect(self.export_recording_list)
         self.ui.import_button.clicked.connect(self.import_recording_list)
         self.ui.default_type_button.toggled.connect(self.model_type_radio_buttons)
+        self.ui.reset_emg_params_button.clicked.connect(self.reset_emg_filter_settings)
+        self.ui.reset_hyperparams_button.clicked.connect(
+            self.reset_hyperparams_settings
+        )
 
         # user input: drag and drop
         self.ui.recording_file_label.installEventFilter(self)
@@ -363,6 +382,7 @@ class AccuSleepWindow(QMainWindow):
             brain_state_set=self.brain_state_set,
             model_type=self.model_type,
             calibration_fraction=calibration_fraction,
+            emg_filter=self.emg_filter,
         )
         if len(failed_recordings) > 0:
             if len(failed_recordings) == len(self.recordings):
@@ -391,6 +411,7 @@ class AccuSleepWindow(QMainWindow):
             img_dir=temp_image_dir,
             mixture_weights=self.brain_state_set.mixture_weights,
             n_classes=self.brain_state_set.n_classes,
+            hyperparameters=self.hyperparameters,
         )
 
         # calibrate the model
@@ -399,7 +420,9 @@ class AccuSleepWindow(QMainWindow):
                 temp_image_dir, CALIBRATION_ANNOTATION_FILENAME
             )
             calibration_dataloader = create_dataloader(
-                annotations_file=calibration_annotation_file, img_dir=temp_image_dir
+                annotations_file=calibration_annotation_file,
+                img_dir=temp_image_dir,
+                hyperparameters=self.hyperparameters,
             )
             model = ModelWithTemperature(model)
             print("Calibrating model")
@@ -584,6 +607,7 @@ class AccuSleepWindow(QMainWindow):
                 epoch_length=self.epoch_length,
                 epochs_per_img=self.model_epochs_per_img,
                 brain_state_set=self.brain_state_set,
+                emg_filter=self.emg_filter,
             )
 
             # overwrite as needed
@@ -801,6 +825,7 @@ class AccuSleepWindow(QMainWindow):
             sampling_rate=sampling_rate,
             epoch_length=self.epoch_length,
             brain_state_set=self.brain_state_set,
+            emg_filter=self.emg_filter,
         )
 
         self.ui.calibration_status.setText("")
@@ -965,6 +990,7 @@ class AccuSleepWindow(QMainWindow):
             confidence_scores=confidence_scores,
             sampling_rate=sampling_rate,
             epoch_length=self.epoch_length,
+            emg_filter=self.emg_filter,
         )
         manual_scoring_window.setWindowTitle(f"AccuSleePy viewer: {label_file}")
         manual_scoring_window.exec()
@@ -1130,15 +1156,6 @@ class AccuSleepWindow(QMainWindow):
 
     def initialize_settings_tab(self):
         """Populate settings tab and assign its callbacks"""
-        # show information about the settings tab
-        config_guide_file = open(
-            os.path.join(os.path.dirname(os.path.abspath(__file__)), CONFIG_GUIDE_FILE),
-            "r",
-        )
-        config_guide_text = config_guide_file.read()
-        config_guide_file.close()
-        self.ui.settings_text.setText(config_guide_text)
-
         # store dictionary that maps digits to rows of widgets
         # in the settings tab
         self.settings_widgets = {
@@ -1215,8 +1232,21 @@ class AccuSleepWindow(QMainWindow):
         }
 
         # update widget state to display current config
+        # UI defaults
         self.ui.default_epoch_input.setValue(self.epoch_length)
-        self.ui.confidence_setting_checkbox.setChecked(self.save_confidence_setting)
+        self.ui.overwrite_default_checkbox.setChecked(self.only_overwrite_undefined)
+        self.ui.confidence_setting_checkbox.setChecked(self.save_confidence_scores)
+        self.ui.default_min_bout_length_spinbox.setValue(self.min_bout_length)
+        # EMG filter
+        self.ui.emg_order_spinbox.setValue(self.emg_filter.order)
+        self.ui.bp_lower_spinbox.setValue(self.emg_filter.bp_lower)
+        self.ui.bp_upper_spinbox.setValue(self.emg_filter.bp_upper)
+        # model training hyperparameters
+        self.ui.batch_size_spinbox.setValue(self.hyperparameters.batch_size)
+        self.ui.learning_rate_spinbox.setValue(self.hyperparameters.learning_rate)
+        self.ui.momentum_spinbox.setValue(self.hyperparameters.momentum)
+        self.ui.training_epochs_spinbox.setValue(self.hyperparameters.training_epochs)
+        # brain states
         states = {b.digit: b for b in self.brain_state_set.brain_states}
         for digit in range(10):
             if digit in states.keys():
@@ -1235,6 +1265,15 @@ class AccuSleepWindow(QMainWindow):
                 self.settings_widgets[digit].frequency_widget.setEnabled(False)
 
         # set callbacks
+        self.ui.emg_order_spinbox.valueChanged.connect(self.emg_filter_order_changed)
+        self.ui.bp_lower_spinbox.valueChanged.connect(self.emg_filter_bp_lower_changed)
+        self.ui.bp_upper_spinbox.valueChanged.connect(self.emg_filter_bp_upper_changed)
+        self.ui.batch_size_spinbox.valueChanged.connect(self.hyperparameters_changed)
+        self.ui.learning_rate_spinbox.valueChanged.connect(self.hyperparameters_changed)
+        self.ui.momentum_spinbox.valueChanged.connect(self.hyperparameters_changed)
+        self.ui.training_epochs_spinbox.valueChanged.connect(
+            self.hyperparameters_changed
+        )
         for digit in range(10):
             state = self.settings_widgets[digit]
             state.enabled_widget.stateChanged.connect(
@@ -1297,6 +1336,41 @@ class AccuSleepWindow(QMainWindow):
         # check that configuration is valid
         _ = self.check_config_validity()
 
+    def emg_filter_order_changed(self, new_value: int) -> None:
+        """Called when user modifies EMG filter order
+
+        :param new_value: new EMG filter order
+        """
+        self.emg_filter.order = new_value
+
+    def emg_filter_bp_lower_changed(self, new_value: int | float) -> None:
+        """Called when user modifies EMG filter lower cutoff
+
+        :param new_value: new lower bandpass cutoff frequency
+        """
+        self.emg_filter.bp_lower = new_value
+        _ = self.check_config_validity()
+
+    def emg_filter_bp_upper_changed(self, new_value: int | float) -> None:
+        """Called when user modifies EMG filter upper cutoff
+
+        :param new_value: new upper bandpass cutoff frequency
+        """
+        self.emg_filter.bp_upper = new_value
+        _ = self.check_config_validity()
+
+    def hyperparameters_changed(self, new_value) -> None:
+        """Called when user modifies model training hyperparameters
+
+        :param new_value: unused
+        """
+        self.hyperparameters = Hyperparameters(
+            batch_size=self.ui.batch_size_spinbox.value(),
+            learning_rate=self.ui.learning_rate_spinbox.value(),
+            momentum=self.ui.momentum_spinbox.value(),
+            training_epochs=self.ui.training_epochs_spinbox.value(),
+        )
+
     def check_config_validity(self) -> str:
         """Check if brain state configuration on screen is valid"""
         # error message, if we get one
@@ -1323,6 +1397,10 @@ class AccuSleepWindow(QMainWindow):
         if sum(frequencies) != 1:
             message = "Error: sum(frequencies) != 1"
 
+        # check validity of EMG filter settings
+        if self.emg_filter.bp_lower >= self.emg_filter.bp_upper:
+            message = "Error: EMG filter cutoff frequencies are invalid"
+
         if message is not None:
             self.ui.save_config_status.setText(message)
             self.ui.save_config_button.setEnabled(False)
@@ -1355,12 +1433,36 @@ class AccuSleepWindow(QMainWindow):
 
         # save to file
         save_config(
-            self.brain_state_set,
-            self.ui.default_epoch_input.value(),
-            self.ui.confidence_setting_checkbox.isChecked(),
+            brain_state_set=self.brain_state_set,
+            default_epoch_length=self.ui.default_epoch_input.value(),
+            overwrite_setting=self.ui.overwrite_default_checkbox.isChecked(),
+            save_confidence_setting=self.ui.confidence_setting_checkbox.isChecked(),
+            min_bout_length=self.ui.default_min_bout_length_spinbox.value(),
+            emg_filter=EMGFilter(
+                order=self.emg_filter.order,
+                bp_lower=self.emg_filter.bp_lower,
+                bp_upper=self.emg_filter.bp_upper,
+            ),
+            hyperparameters=Hyperparameters(
+                batch_size=self.hyperparameters.batch_size,
+                learning_rate=self.hyperparameters.learning_rate,
+                momentum=self.hyperparameters.momentum,
+                training_epochs=self.hyperparameters.training_epochs,
+            ),
         )
         self.ui.save_config_status.setText("configuration saved")
 
+    def reset_emg_filter_settings(self) -> None:
+        self.ui.emg_order_spinbox.setValue(DEFAULT_EMG_FILTER_ORDER)
+        self.ui.bp_lower_spinbox.setValue(DEFAULT_EMG_BP_LOWER)
+        self.ui.bp_upper_spinbox.setValue(DEFAULT_EMG_BP_UPPER)
+
+    def reset_hyperparams_settings(self):
+        self.ui.batch_size_spinbox.setValue(DEFAULT_BATCH_SIZE)
+        self.ui.learning_rate_spinbox.setValue(DEFAULT_LEARNING_RATE)
+        self.ui.momentum_spinbox.setValue(DEFAULT_MOMENTUM)
+        self.ui.training_epochs_spinbox.setValue(DEFAULT_TRAINING_EPOCHS)
+
 
 def check_label_validity(
     labels: np.array,