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

accusleepy/gui/main.py

@@ -39,7 +39,15 @@ 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,
+    MESSAGE_BOX_MAX_DEPTH,
     MODEL_FILE_TYPE,
     REAL_TIME_MODEL_TYPE,
     RECORDING_FILE_TYPES,
@@ -56,6 +64,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
@@ -63,14 +73,15 @@ from accusleepy.signal_processing import (
     create_training_images,
     resample_and_standardize,
 )
+from accusleepy.validation import (
+    check_label_validity,
+    LABEL_LENGTH_ERROR,
+    check_config_consistency,
+)
 
 # note: functions using torch or scipy are lazily imported
 
-# max number of messages to display
-MESSAGE_BOX_MAX_DEPTH = 200
-LABEL_LENGTH_ERROR = "label file length does not match recording length"
-# relative path to config guide txt file
-CONFIG_GUIDE_FILE = os.path.normpath(r"text/config_guide.txt")
+# relative path to user manual
 MAIN_GUIDE_FILE = os.path.normpath(r"text/main_guide.md")
 
 
@@ -97,19 +108,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 +203,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)
@@ -200,10 +221,9 @@ class AccuSleepWindow(QMainWindow):
 
         :param default_selected: whether default option is selected
         """
-        if default_selected:
-            self.model_type = DEFAULT_MODEL_TYPE
-        else:
-            self.model_type = REAL_TIME_MODEL_TYPE
+        self.model_type = (
+            DEFAULT_MODEL_TYPE if default_selected else REAL_TIME_MODEL_TYPE
+        )
 
     def export_recording_list(self) -> None:
         """Save current list of recordings to file"""
@@ -363,6 +383,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 +412,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 +421,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 +608,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 +826,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 +991,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 +1157,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 +1233,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,16 +1266,25 @@ 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(
                 partial(self.set_brain_state_enabled, digit)
             )
-            state.name_widget.editingFinished.connect(self.finished_editing_state_name)
+            state.name_widget.editingFinished.connect(self.check_config_validity)
             state.is_scored_widget.stateChanged.connect(
                 partial(self.is_scored_changed, digit)
             )
-            state.frequency_widget.valueChanged.connect(self.state_frequency_changed)
+            state.frequency_widget.valueChanged.connect(self.check_config_validity)
 
     def set_brain_state_enabled(self, digit, e) -> None:
         """Called when user clicks "enabled" checkbox
@@ -1270,17 +1310,6 @@ class AccuSleepWindow(QMainWindow):
         # check that configuration is valid
         _ = self.check_config_validity()
 
-    def finished_editing_state_name(self) -> None:
-        """Called when user finishes editing a brain state's name"""
-        _ = self.check_config_validity()
-
-    def state_frequency_changed(self, new_value) -> None:
-        """Called when user edits a brain state's frequency
-
-        :param new_value: unused
-        """
-        _ = self.check_config_validity()
-
     def is_scored_changed(self, digit, e) -> None:
         """Called when user sets whether a state is scored
 
@@ -1297,6 +1326,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 +1387,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,133 +1423,35 @@ 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 check_label_validity(
-    labels: np.array,
-    confidence_scores: np.array,
-    samples_in_recording: int,
-    sampling_rate: int | float,
-    epoch_length: int | float,
-    brain_state_set: BrainStateSet,
-) -> str | None:
-    """Check whether a set of brain state labels is valid
-
-    This returns an error message if a problem is found with the
-    brain state labels.
-
-    :param labels: brain state labels
-    :param confidence_scores: confidence scores
-    :param samples_in_recording: number of samples in the recording
-    :param sampling_rate: sampling rate, in Hz
-    :param epoch_length: epoch length, in seconds
-    :param brain_state_set: BrainStateMapper object
-    :return: error message
-    """
-    # check that number of labels is correct
-    samples_per_epoch = round(sampling_rate * epoch_length)
-    epochs_in_recording = round(samples_in_recording / samples_per_epoch)
-    if epochs_in_recording != labels.size:
-        return LABEL_LENGTH_ERROR
-
-    # check that entries are valid
-    if not set(labels.tolist()).issubset(
-        set([b.digit for b in brain_state_set.brain_states] + [UNDEFINED_LABEL])
-    ):
-        return "label file contains invalid entries"
-
-    if confidence_scores is not None:
-        if np.min(confidence_scores) < 0 or np.max(confidence_scores) > 1:
-            return "label file contains invalid confidence scores"
-
-    return None
-
-
-def check_config_consistency(
-    current_brain_states: dict,
-    model_brain_states: dict,
-    current_epoch_length: int | float,
-    model_epoch_length: int | float,
-) -> list[str]:
-    """Compare current brain state config to the model's config
-
-    This only displays warnings - the user should decide whether to proceed
-
-    :param current_brain_states: current brain state config
-    :param model_brain_states: brain state config when the model was created
-    :param current_epoch_length: current epoch length setting
-    :param model_epoch_length: epoch length used when the model was created
-    """
-    output = list()
-
-    # make lists of names and digits for scored brain states
-    current_scored_states = {
-        f: [b[f] for b in current_brain_states if b["is_scored"]]
-        for f in ["name", "digit"]
-    }
-    model_scored_states = {
-        f: [b[f] for b in model_brain_states if b["is_scored"]]
-        for f in ["name", "digit"]
-    }
-
-    # generate message comparing the brain state configs
-    config_comparisons = list()
-    for config, config_name in zip(
-        [current_scored_states, model_scored_states], ["current", "model's"]
-    ):
-        config_comparisons.append(
-            f"Scored brain states in {config_name} configuration: "
-            f"""{
-                ", ".join(
-                    [
-                        f"{x}: {y}"
-                        for x, y in zip(
-                            config["digit"],
-                            config["name"],
-                        )
-                    ]
-                )
-            }"""
-        )
-
-    # check if the number of scored states is different
-    len_diff = len(current_scored_states["name"]) - len(model_scored_states["name"])
-    if len_diff != 0:
-        output.append(
-            (
-                "WARNING: current brain state configuration has "
-                f"{'fewer' if len_diff < 0 else 'more'} "
-                "scored brain states than the model's configuration."
-            )
-        )
-        output = output + config_comparisons
-    else:
-        # the length is the same, but names might be different
-        if current_scored_states["name"] != model_scored_states["name"]:
-            output.append(
-                (
-                    "WARNING: current brain state configuration appears "
-                    "to contain different brain states than "
-                    "the model's configuration."
-                )
-            )
-            output = output + config_comparisons
-
-    if current_epoch_length != model_epoch_length:
-        output.append(
-            (
-                "Warning: the epoch length used when training this model "
-                f"({model_epoch_length} seconds) "
-                "does not match the current epoch length setting."
-            )
-        )
-
-    return output
+    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 run_primary_window() -> None:

accusleepy/gui/manual_scoring.py

@@ -32,7 +32,7 @@ from PySide6.QtWidgets import (
 )
 
 from accusleepy.constants import UNDEFINED_LABEL
-from accusleepy.fileio import load_config, save_labels
+from accusleepy.fileio import load_config, save_labels, EMGFilter
 from accusleepy.gui.mplwidget import resample_x_ticks
 from accusleepy.gui.viewer_window import Ui_ViewerWindow
 from accusleepy.signal_processing import create_spectrogram, get_emg_power
@@ -79,6 +79,12 @@ UNDEFINED_STATE = "undefined"
 SCROLL_BOUNDARY = 0.35
 # max number of sequential undo actions allowed
 UNDO_LIMIT = 1000
+# brightness scaling factors for the spectrogram
+BRIGHTER_SCALE_FACTOR = 0.96
+DIMMER_SCALE_FACTOR = 1.07
+# zoom factor for upper plots
+ZOOM_IN_FACTOR = 0.45
+ZOOM_OUT_FACTOR = 1.017
 
 
 @dataclass
@@ -102,6 +108,7 @@ class ManualScoringWindow(QDialog):
         confidence_scores: np.array,
         sampling_rate: int | float,
         epoch_length: int | float,
+        emg_filter: EMGFilter,
     ):
         """Initialize the manual scoring window
 
@@ -112,6 +119,7 @@ class ManualScoringWindow(QDialog):
         :param confidence_scores: confidence scores
         :param sampling_rate: sampling rate, in Hz
         :param epoch_length: epoch length, in seconds
+        :param emg_filter: EMG filter parameters
         """
         super(ManualScoringWindow, self).__init__()
 
@@ -122,6 +130,7 @@ class ManualScoringWindow(QDialog):
         self.confidence_scores = confidence_scores
         self.sampling_rate = sampling_rate
         self.epoch_length = epoch_length
+        self.emg_filter = emg_filter
 
         self.n_epochs = len(self.labels)
 
@@ -131,7 +140,7 @@ class ManualScoringWindow(QDialog):
         self.setWindowTitle("AccuSleePy manual scoring window")
 
         # load set of valid brain states
-        self.brain_state_set, _, _ = load_config()
+        self.brain_state_set, _, _, _, _, _, _ = load_config()
 
         # initial setting for number of epochs to show in the lower plot
         self.epochs_to_show = 5
@@ -153,7 +162,7 @@ class ManualScoringWindow(QDialog):
 
         # calculate RMS of EMG for each epoch and apply a ceiling
         self.upper_emg = create_upper_emg_signal(
-            self.emg, self.sampling_rate, self.epoch_length
+            self.emg, self.sampling_rate, self.epoch_length, self.emg_filter
         )
 
         # center and scale the EEG and EMG signals to fit the display
@@ -229,23 +238,6 @@ class ManualScoringWindow(QDialog):
         keypress_zoom_out_x = QShortcut(QKeySequence(Qt.Key.Key_Minus), self)
         keypress_zoom_out_x.activated.connect(partial(self.zoom_x, ZOOM_OUT))
 
-        keypress_modify_label = list()
-        for brain_state in self.brain_state_set.brain_states:
-            keypress_modify_label.append(
-                QShortcut(
-                    QKeySequence(Qt.Key[f"Key_{brain_state.digit}"]),
-                    self,
-                )
-            )
-            keypress_modify_label[-1].activated.connect(
-                partial(self.modify_current_epoch_label, brain_state.digit)
-            )
-
-        keypress_delete_label = QShortcut(QKeySequence(Qt.Key.Key_Backspace), self)
-        keypress_delete_label.activated.connect(
-            partial(self.modify_current_epoch_label, UNDEFINED_LABEL)
-        )
-
         keypress_quit = QShortcut(
             QKeySequence(QKeyCombination(Qt.Modifier.CTRL, Qt.Key.Key_W)),
             self,
@@ -258,36 +250,37 @@ class ManualScoringWindow(QDialog):
         )
         keypress_save.activated.connect(self.save)
 
+        keypress_modify_label = list()
         keypress_roi = list()
-        for brain_state in self.brain_state_set.brain_states:
+        digit_key_label_pairs = [
+            (Qt.Key[f"Key_{brain_state.digit}"], brain_state.digit)
+            for brain_state in self.brain_state_set.brain_states
+        ] + [(Qt.Key.Key_Backspace, UNDEFINED_LABEL)]
+
+        for digit_key, digit_label in digit_key_label_pairs:
+            keypress_modify_label.append(
+                QShortcut(
+                    QKeySequence(digit_key),
+                    self,
+                )
+            )
+            keypress_modify_label[-1].activated.connect(
+                partial(self.modify_current_epoch_label, digit_label)
+            )
             keypress_roi.append(
                 QShortcut(
                     QKeySequence(
                         QKeyCombination(
                             Qt.Modifier.SHIFT,
-                            Qt.Key[f"Key_{brain_state.digit}"],
+                            digit_key,
                         )
                     ),
                     self,
                 )
             )
             keypress_roi[-1].activated.connect(
-                partial(self.enter_label_roi_mode, brain_state.digit)
-            )
-        keypress_roi.append(
-            QShortcut(
-                QKeySequence(
-                    QKeyCombination(
-                        Qt.Modifier.SHIFT,
-                        Qt.Key.Key_Backspace,
-                    )
-                ),
-                self,
+                partial(self.enter_label_roi_mode, digit_label)
             )
-        )
-        keypress_roi[-1].activated.connect(
-            partial(self.enter_label_roi_mode, UNDEFINED_LABEL)
-        )
 
         keypress_esc = QShortcut(QKeySequence(Qt.Key.Key_Escape), self)
         keypress_esc.activated.connect(self.exit_label_roi_mode)
@@ -623,9 +616,9 @@ class ManualScoringWindow(QDialog):
         """
         vmin, vmax = self.ui.upperfigure.spec_ref.get_clim()
         if direction == BRIGHTER:
-            self.ui.upperfigure.spec_ref.set(clim=(vmin, vmax * 0.96))
+            self.ui.upperfigure.spec_ref.set(clim=(vmin, vmax * BRIGHTER_SCALE_FACTOR))
         else:
-            self.ui.upperfigure.spec_ref.set(clim=(vmin, vmax * 1.07))
+            self.ui.upperfigure.spec_ref.set(clim=(vmin, vmax * DIMMER_SCALE_FACTOR))
         self.ui.upperfigure.canvas.draw()
 
     def update_epochs_shown(self, direction: str) -> None:
@@ -722,31 +715,29 @@ class ManualScoringWindow(QDialog):
 
         :param direction: in, out, or reset
         """
-        zoom_in_factor = 0.45
-        zoom_out_factor = 1.017
         epochs_shown = self.upper_right_epoch - self.upper_left_epoch + 1
         if direction == ZOOM_IN:
             self.upper_left_epoch = max(
                 [
                     self.upper_left_epoch,
-                    round(self.epoch - zoom_in_factor * epochs_shown),
+                    round(self.epoch - ZOOM_IN_FACTOR * epochs_shown),
                 ]
             )
 
             self.upper_right_epoch = min(
                 [
                     self.upper_right_epoch,
-                    round(self.epoch + zoom_in_factor * epochs_shown),
+                    round(self.epoch + ZOOM_IN_FACTOR * epochs_shown),
                 ]
             )
 
         elif direction == ZOOM_OUT:
             self.upper_left_epoch = max(
-                [0, round(self.epoch - zoom_out_factor * epochs_shown)]
+                [0, round(self.epoch - ZOOM_OUT_FACTOR * epochs_shown)]
             )
 
             self.upper_right_epoch = min(
-                [self.n_epochs - 1, round(self.epoch + zoom_out_factor * epochs_shown)]
+                [self.n_epochs - 1, round(self.epoch + ZOOM_OUT_FACTOR * epochs_shown)]
             )
 
         else:  # reset
@@ -1063,21 +1054,28 @@ def create_confidence_img(confidence_scores: np.array) -> np.array:
 
 
 def create_upper_emg_signal(
-    emg: np.array, sampling_rate: int | float, epoch_length: int | float
+    emg: np.array,
+    sampling_rate: int | float,
+    epoch_length: int | float,
+    emg_filter: EMGFilter,
 ) -> np.array:
     """Calculate RMS of EMG for each epoch and apply a ceiling
 
     :param emg: EMG signal
     :param sampling_rate: sampling rate, in Hz
     :param epoch_length: epoch length, in seconds
+    :param emg_filter: EMG filter parameters
     :return: processed EMG signal
     """
     emg_rms = get_emg_power(
         emg,
         sampling_rate,
         epoch_length,
+        emg_filter,
+    )
+    return np.clip(
+        emg_rms, np.percentile(emg_rms, 0.1), np.mean(emg_rms) + np.std(emg_rms) * 2.5
     )
-    return np.clip(emg_rms, 0, np.mean(emg_rms) + np.std(emg_rms) * 2.5)
 
 
 def transform_eeg_emg(eeg: np.array, emg: np.array) -> (np.array, np.array):