PyPI - accusleepy - Versions diffs - 0.8.0__py3-none-any.whl → 0.9.2__py3-none-any.whl - Mend

accusleepy 0.8.0py3-none-any.whl → 0.9.2py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

accusleepy/bouts.py +46 -38
accusleepy/brain_state_set.py +6 -4
accusleepy/classification.py +14 -50
accusleepy/constants.py +3 -0
accusleepy/fileio.py +58 -27
accusleepy/gui/dialogs.py +40 -0
accusleepy/gui/images/primary_window.png +0 -0
accusleepy/gui/main.py +212 -1026
accusleepy/gui/manual_scoring.py +5 -13
accusleepy/gui/primary_window.py +7 -9
accusleepy/gui/primary_window.ui +6 -8
accusleepy/gui/recording_manager.py +110 -0
accusleepy/gui/settings_widget.py +409 -0
accusleepy/gui/text/main_guide.md +1 -1
accusleepy/models.py +1 -1
accusleepy/services.py +581 -0
accusleepy/signal_processing.py +110 -38
accusleepy/temperature_scaling.py +14 -8
accusleepy/validation.py +67 -2
{accusleepy-0.8.0.dist-info → accusleepy-0.9.2.dist-info}/METADATA +3 -5
{accusleepy-0.8.0.dist-info → accusleepy-0.9.2.dist-info}/RECORD +22 -18
{accusleepy-0.8.0.dist-info → accusleepy-0.9.2.dist-info}/WHEEL +1 -1

accusleepy/gui/manual_scoring.py CHANGED Viewed

@@ -139,18 +139,10 @@ class ManualScoringWindow(QDialog):
         self.ui.setupUi(self)
         self.setWindowTitle("AccuSleePy manual scoring window")
-        # load set of valid brain states
-        (
-            self.brain_state_set,
-            _,
-            _,
-            _,
-            _,
-            _,
-            _,
-            self.epochs_to_show,
-            self.autoscroll_state,
-        ) = load_config()
+        config = load_config()
+        self.brain_state_set = config.brain_state_set
+        self.epochs_to_show = config.epochs_to_show
+        self.autoscroll_state = config.autoscroll_state
         # find the set of y-axis locations of valid brain state labels
         self.label_display_options = convert_labels(
@@ -1018,7 +1010,7 @@ def convert_labels(labels: np.array, style: str) -> np.array:
         labels = [i if i != 0 else UNDEFINED_LABEL for i in labels]
         return np.array([i if i != 10 else 0 for i in labels])
     else:
-        raise Exception(f"style must be '{DISPLAY_FORMAT}' or '{DIGIT_FORMAT}'")
+        raise ValueError(f"style must be '{DISPLAY_FORMAT}' or '{DIGIT_FORMAT}'")
 def create_label_img(labels: np.array, label_display_options: np.array) -> np.array:

accusleepy/gui/primary_window.py CHANGED Viewed

@@ -3,7 +3,7 @@
 ################################################################################
 ## Form generated from reading UI file 'primary_window.ui'
 ##
-## Created by: Qt User Interface Compiler version 6.9.0
+## Created by: Qt User Interface Compiler version 6.9.2
 ##
 ## WARNING! All changes made in this file will be lost when recompiling UI file!
 ################################################################################
@@ -3153,16 +3153,16 @@ class Ui_PrimaryWindow(object):
             QCoreApplication.translate(
                 "PrimaryWindow",
                 "This is the current set of brain states. Important notes:\n"
-                "- You must click 'Save settings' to store any changes.\n"
+                "- You must click 'Save settings' for changes to take effect.\n"
                 "- Changing these settings can prevent existing label files, calibration files, and trained models from working properly.\n"
                 "- Reinstalling AccuSleePy will overwrite this configuration.\n"
                 "\n"
                 "Each brain state has several attributes:\n"
-                "- Digit: how the brain state is represented in label files, and keyboard shortcut for this state in manual scoring.\n"
+                "- Digit: the indicator for this state in label files, and the keyboard shortcut for this state in manual scoring.\n"
                 "- Enabled: whether a brain state for this digit exists.\n"
                 "- Name: unique name of the brain state (e.g., REM).\n"
-                "- Scored: whether a classification model should output this brain state. If a state  corresponds to missing/corrupted data, you probably want to uncheck this box.\n"
-                "- Frequency: approximate relative frequency of this brain state. Does not need to be very accurate. Frequencies for all scored states must sum to 1.",
+                "- Scored: whether a classification model should output this brain state. If a state corresponds to missing/corrupted data, you probably want to uncheck this box.\n"
+                "- Frequency: approximate relative frequency of this brain state. Does not need to be very accurate. Frequencies for scored states must sum to 1.",
                 None,
             )
         )
@@ -3255,7 +3255,7 @@ class Ui_PrimaryWindow(object):
         self.ui_default_description_label.setText(
             QCoreApplication.translate(
                 "PrimaryWindow",
-                "<html><head/><body><p>These are the default values/settings that are shown in the primary window and manual scoring window when they start up.</p><p>Changes here will not affect the **current** state of the controls in the &quot;Sleep scoring&quot; tab.</p></body></html>",
+                "<html><head/><body><p>These are the default values/settings that are shown in the primary window and manual scoring window when they start up.</p><p>Changes here will not affect the **current** state of the controls in the &quot;Sleep scoring&quot; tab.</p><p>You must click 'Save settings' for changes to take effect.</p></body></html>",
                 None,
             )
         )
@@ -3280,9 +3280,7 @@ class Ui_PrimaryWindow(object):
         self.emg_filter_description_label.setText(
             QCoreApplication.translate(
                 "PrimaryWindow",
-                "EMG power is calculated as the root-mean-square of the EMG signal in each epoch after a bandpass filter is applied. You can change the proprties of that filter here. If the manual scoring window displays the EMG signal but not the EMG power, you can try lowering the filter order to 4.\n"
-                "\n"
-                "Changing these settings can prevent existing classification models and calibration files from working as expected. You will probably want to recreate them using your new settings.",
+                "<html><head/><body><p>EMG power is calculated as the root-mean-square of the EMG signal in each epoch after a bandpass filter is applied. You can change the proprties of that filter here. If the manual scoring window displays the EMG signal but not the EMG power, you can try lowering the filter order to 4.</p><p>Changing these settings can prevent existing classification models and calibration files from working as expected. You will probably want to recreate them using your new settings.</p><p>You must click 'Save settings' for changes to take effect.</p></body></html>",
                 None,
             )
         )

accusleepy/gui/primary_window.ui CHANGED Viewed

@@ -3750,16 +3750,16 @@ color: rgb(244, 195, 68);</string>
                     </property>
                     <property name="text">
                      <string>This is the current set of brain states. Important notes:
-- You must click 'Save settings' to store any changes.
+- You must click 'Save settings' for changes to take effect.
 - Changing these settings can prevent existing label files, calibration files, and trained models from working properly.
 - Reinstalling AccuSleePy will overwrite this configuration.
 Each brain state has several attributes:
-- Digit: how the brain state is represented in label files, and keyboard shortcut for this state in manual scoring.
+- Digit: the indicator for this state in label files, and the keyboard shortcut for this state in manual scoring.
 - Enabled: whether a brain state for this digit exists.
 - Name: unique name of the brain state (e.g., REM).
-- Scored: whether a classification model should output this brain state. If a state  corresponds to missing/corrupted data, you probably want to uncheck this box.
-- Frequency: approximate relative frequency of this brain state. Does not need to be very accurate. Frequencies for all scored states must sum to 1.</string>
+- Scored: whether a classification model should output this brain state. If a state corresponds to missing/corrupted data, you probably want to uncheck this box.
+- Frequency: approximate relative frequency of this brain state. Does not need to be very accurate. Frequencies for scored states must sum to 1.</string>
                     </property>
                     <property name="textFormat">
                      <enum>Qt::TextFormat::MarkdownText</enum>
@@ -4112,7 +4112,7 @@ Each brain state has several attributes:
                      <string notr="true">background-color: white;</string>
                     </property>
                     <property name="text">
-                     <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;These are the default values/settings that are shown in the primary window and manual scoring window when they start up.&lt;/p&gt;&lt;p&gt;Changes here will not affect the **current** state of the controls in the &amp;quot;Sleep scoring&amp;quot; tab.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+                     <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;These are the default values/settings that are shown in the primary window and manual scoring window when they start up.&lt;/p&gt;&lt;p&gt;Changes here will not affect the **current** state of the controls in the &amp;quot;Sleep scoring&amp;quot; tab.&lt;/p&gt;&lt;p&gt;You must click 'Save settings' for changes to take effect.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                     </property>
                     <property name="textFormat">
                      <enum>Qt::TextFormat::MarkdownText</enum>
@@ -4364,9 +4364,7 @@ Each brain state has several attributes:
                      <string notr="true">background-color: white;</string>
                     </property>
                     <property name="text">
-                     <string>EMG power is calculated as the root-mean-square of the EMG signal in each epoch after a bandpass filter is applied. You can change the proprties of that filter here. If the manual scoring window displays the EMG signal but not the EMG power, you can try lowering the filter order to 4.
-Changing these settings can prevent existing classification models and calibration files from working as expected. You will probably want to recreate them using your new settings.</string>
+                     <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;EMG power is calculated as the root-mean-square of the EMG signal in each epoch after a bandpass filter is applied. You can change the proprties of that filter here. If the manual scoring window displays the EMG signal but not the EMG power, you can try lowering the filter order to 4.&lt;/p&gt;&lt;p&gt;Changing these settings can prevent existing classification models and calibration files from working as expected. You will probably want to recreate them using your new settings.&lt;/p&gt;&lt;p&gt;You must click 'Save settings' for changes to take effect.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                     </property>
                     <property name="alignment">
                      <set>Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop</set>

accusleepy/gui/recording_manager.py ADDED Viewed

@@ -0,0 +1,110 @@
+"""Recording list manager"""
+from PySide6.QtCore import QObject
+from PySide6.QtWidgets import QListWidget, QListWidgetItem
+from accusleepy.fileio import Recording, load_recording_list, save_recording_list
+class RecordingListManager(QObject):
+    """Manages the list of recordings and the associated QListWidget"""
+    def __init__(self, list_widget: QListWidget, parent: QObject | None = None):
+        super().__init__(parent)
+        self._widget = list_widget
+        # Create initial empty recording (there is always at least one)
+        first_recording = Recording(
+            widget=QListWidgetItem("Recording 1", self._widget),
+        )
+        self._recordings: list[Recording] = [first_recording]
+        self._widget.addItem(first_recording.widget)
+        self._widget.setCurrentRow(0)
+    @property
+    def current(self) -> Recording:
+        """The currently selected recording"""
+        return self._recordings[self._widget.currentRow()]
+    def add(self, sampling_rate: int | float) -> Recording:
+        """Add a new recording to the list
+        :param sampling_rate: sampling rate for the new recording
+        :return: the newly created Recording
+        """
+        new_name = max(r.name for r in self._recordings) + 1
+        # Create recording with widget
+        recording = Recording(
+            name=new_name,
+            sampling_rate=sampling_rate,
+            widget=QListWidgetItem(f"Recording {new_name}", self._widget),
+        )
+        self._recordings.append(recording)
+        # Update widget
+        self._widget.addItem(recording.widget)
+        self._widget.setCurrentRow(len(self._recordings) - 1)
+        return recording
+    def remove_current(self) -> str:
+        """Remove the currently selected recording
+        :return: message describing what was removed/reset
+        """
+        if len(self._recordings) > 1:
+            # Remove from list and widget
+            index = self._widget.currentRow()
+            recording_name = self._recordings[index].name
+            self._widget.takeItem(index)
+            del self._recordings[index]
+            return f"deleted Recording {recording_name}"
+        else:
+            # Reset the single recording to defaults
+            recording_name = self._recordings[0].name
+            self._recordings[0] = Recording(widget=self._recordings[0].widget)
+            self._recordings[0].widget.setText(f"Recording {self._recordings[0].name}")
+            return f"cleared Recording {recording_name}"
+    def export_to_file(self, filename: str) -> None:
+        """Save the recording list to a file
+        :param filename: path to which the list will be exported
+        """
+        save_recording_list(filename=filename, recordings=self._recordings)
+    def import_from_file(self, filename: str) -> None:
+        """Load a recording list from a file, replacing current list
+        :param filename: path to load from
+        """
+        # Block signals while rebuilding the list to avoid triggering
+        # selection callbacks with invalid state
+        self._widget.blockSignals(True)
+        try:
+            self._widget.clear()
+            # Load recordings
+            self._recordings = load_recording_list(filename)
+            # Create widgets for each recording
+            for recording in self._recordings:
+                recording.widget = QListWidgetItem(
+                    f"Recording {recording.name}", self._widget
+                )
+                self._widget.addItem(recording.widget)
+        finally:
+            self._widget.blockSignals(False)
+        # Select first recording (this will trigger the selection callback)
+        self._widget.setCurrentRow(0)
+    def __iter__(self):
+        return iter(self._recordings)
+    def __len__(self):
+        return len(self._recordings)
+    def __getitem__(self, index: int) -> Recording:
+        return self._recordings[index]

accusleepy/gui/settings_widget.py ADDED Viewed

@@ -0,0 +1,409 @@
+"""Settings tab manager"""
+from dataclasses import dataclass
+from functools import partial
+from PySide6.QtCore import QObject
+from PySide6.QtWidgets import QCheckBox, QDoubleSpinBox, QLineEdit
+from accusleepy.brain_state_set import BrainState, BrainStateSet
+from accusleepy.constants import (
+    DEFAULT_BATCH_SIZE,
+    DEFAULT_EMG_BP_LOWER,
+    DEFAULT_EMG_BP_UPPER,
+    DEFAULT_EMG_FILTER_ORDER,
+    DEFAULT_LEARNING_RATE,
+    DEFAULT_MOMENTUM,
+    DEFAULT_TRAINING_EPOCHS,
+    UNDEFINED_LABEL,
+)
+from accusleepy.fileio import (
+    AccuSleePyConfig,
+    EMGFilter,
+    Hyperparameters,
+    save_config,
+)
+from accusleepy.gui.primary_window import Ui_PrimaryWindow
+@dataclass
+class StateSettings:
+    """Widgets for config settings for a brain state"""
+    digit: int
+    enabled_widget: QCheckBox
+    name_widget: QLineEdit
+    is_scored_widget: QCheckBox
+    frequency_widget: QDoubleSpinBox
+class SettingsWidget(QObject):
+    """Manages settings tab UI and configuration data"""
+    def __init__(
+        self,
+        ui: Ui_PrimaryWindow,
+        config: AccuSleePyConfig,
+        parent: QObject | None = None,
+    ):
+        super().__init__(parent)
+        self._ui = ui
+        # Store configuration values (only settings managed by the Settings tab)
+        self._brain_state_set = config.brain_state_set
+        self._emg_filter = config.emg_filter
+        self._hyperparameters = config.hyperparameters
+        self._default_epochs_to_show = config.epochs_to_show
+        self._default_autoscroll_state = config.autoscroll_state
+        # Store default values for main tab settings (used to populate Settings tab UI)
+        self._default_epoch_length = config.default_epoch_length
+        self._default_overwrite_setting = config.overwrite_setting
+        self._default_confidence_setting = config.save_confidence_setting
+        self._default_min_bout_length = config.min_bout_length
+        # Initialize settings widgets
+        self._settings_widgets: dict[int, StateSettings] = {}
+        self._initialize_settings_tab()
+    @property
+    def brain_state_set(self) -> BrainStateSet:
+        """The current brain state set configuration (from saved config)"""
+        return self._brain_state_set
+    @property
+    def emg_filter(self) -> EMGFilter:
+        """EMG filter parameters (from saved config)"""
+        return self._emg_filter
+    @property
+    def hyperparameters(self) -> Hyperparameters:
+        """Model training hyperparameters"""
+        return self._hyperparameters
+    @property
+    def default_epochs_to_show(self) -> int:
+        """Default number of epochs to show in manual scoring"""
+        return self._default_epochs_to_show
+    @property
+    def default_autoscroll_state(self) -> bool:
+        """Default autoscroll state for manual scoring"""
+        return self._default_autoscroll_state
+    def _initialize_settings_tab(self) -> None:
+        """Populate settings tab and assign its callbacks"""
+        # Store dictionary that maps digits to rows of widgets
+        self._settings_widgets = {
+            1: StateSettings(
+                digit=1,
+                enabled_widget=self._ui.enable_state_1,
+                name_widget=self._ui.state_name_1,
+                is_scored_widget=self._ui.state_scored_1,
+                frequency_widget=self._ui.state_frequency_1,
+            ),
+            2: StateSettings(
+                digit=2,
+                enabled_widget=self._ui.enable_state_2,
+                name_widget=self._ui.state_name_2,
+                is_scored_widget=self._ui.state_scored_2,
+                frequency_widget=self._ui.state_frequency_2,
+            ),
+            3: StateSettings(
+                digit=3,
+                enabled_widget=self._ui.enable_state_3,
+                name_widget=self._ui.state_name_3,
+                is_scored_widget=self._ui.state_scored_3,
+                frequency_widget=self._ui.state_frequency_3,
+            ),
+            4: StateSettings(
+                digit=4,
+                enabled_widget=self._ui.enable_state_4,
+                name_widget=self._ui.state_name_4,
+                is_scored_widget=self._ui.state_scored_4,
+                frequency_widget=self._ui.state_frequency_4,
+            ),
+            5: StateSettings(
+                digit=5,
+                enabled_widget=self._ui.enable_state_5,
+                name_widget=self._ui.state_name_5,
+                is_scored_widget=self._ui.state_scored_5,
+                frequency_widget=self._ui.state_frequency_5,
+            ),
+            6: StateSettings(
+                digit=6,
+                enabled_widget=self._ui.enable_state_6,
+                name_widget=self._ui.state_name_6,
+                is_scored_widget=self._ui.state_scored_6,
+                frequency_widget=self._ui.state_frequency_6,
+            ),
+            7: StateSettings(
+                digit=7,
+                enabled_widget=self._ui.enable_state_7,
+                name_widget=self._ui.state_name_7,
+                is_scored_widget=self._ui.state_scored_7,
+                frequency_widget=self._ui.state_frequency_7,
+            ),
+            8: StateSettings(
+                digit=8,
+                enabled_widget=self._ui.enable_state_8,
+                name_widget=self._ui.state_name_8,
+                is_scored_widget=self._ui.state_scored_8,
+                frequency_widget=self._ui.state_frequency_8,
+            ),
+            9: StateSettings(
+                digit=9,
+                enabled_widget=self._ui.enable_state_9,
+                name_widget=self._ui.state_name_9,
+                is_scored_widget=self._ui.state_scored_9,
+                frequency_widget=self._ui.state_frequency_9,
+            ),
+            0: StateSettings(
+                digit=0,
+                enabled_widget=self._ui.enable_state_0,
+                name_widget=self._ui.state_name_0,
+                is_scored_widget=self._ui.state_scored_0,
+                frequency_widget=self._ui.state_frequency_0,
+            ),
+        }
+        # Update widget state to display current config
+        # UI defaults for main tab settings (shown in Settings tab for configuration)
+        self._ui.default_epoch_input.setValue(self._default_epoch_length)
+        self._ui.overwrite_default_checkbox.setChecked(self._default_overwrite_setting)
+        self._ui.confidence_setting_checkbox.setChecked(
+            self._default_confidence_setting
+        )
+        self._ui.default_min_bout_length_spinbox.setValue(self._default_min_bout_length)
+        self._ui.epochs_to_show_spinbox.setValue(self._default_epochs_to_show)
+        self._ui.autoscroll_checkbox.setChecked(self._default_autoscroll_state)
+        # 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():
+                self._settings_widgets[digit].enabled_widget.setChecked(True)
+                self._settings_widgets[digit].name_widget.setText(states[digit].name)
+                self._settings_widgets[digit].is_scored_widget.setChecked(
+                    states[digit].is_scored
+                )
+                self._settings_widgets[digit].frequency_widget.setValue(
+                    states[digit].frequency
+                )
+            else:
+                self._settings_widgets[digit].enabled_widget.setChecked(False)
+                self._settings_widgets[digit].name_widget.setEnabled(False)
+                self._settings_widgets[digit].is_scored_widget.setEnabled(False)
+                self._settings_widgets[digit].frequency_widget.setEnabled(False)
+        # Set callbacks
+        self._ui.default_epoch_input.valueChanged.connect(self.reset_status_message)
+        self._ui.overwrite_default_checkbox.stateChanged.connect(
+            self.reset_status_message
+        )
+        self._ui.confidence_setting_checkbox.stateChanged.connect(
+            self.reset_status_message
+        )
+        self._ui.default_min_bout_length_spinbox.valueChanged.connect(
+            self.reset_status_message
+        )
+        self._ui.epochs_to_show_spinbox.valueChanged.connect(self.reset_status_message)
+        self._ui.autoscroll_checkbox.stateChanged.connect(self.reset_status_message)
+        self._ui.emg_order_spinbox.valueChanged.connect(self.reset_status_message)
+        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.check_validity)
+            state.is_scored_widget.stateChanged.connect(
+                partial(self._is_scored_changed, digit)
+            )
+            state.frequency_widget.valueChanged.connect(self.check_validity)
+    def _set_brain_state_enabled(self, digit: int, _state: int) -> None:
+        """Called when user clicks "enabled" checkbox
+        :param digit: brain state digit
+        :param _state: unused but mandatory
+        """
+        state = self._settings_widgets[digit]
+        is_checked = state.enabled_widget.isChecked()
+        for widget in [
+            state.name_widget,
+            state.is_scored_widget,
+        ]:
+            widget.setEnabled(is_checked)
+        state.frequency_widget.setEnabled(
+            is_checked and state.is_scored_widget.isChecked()
+        )
+        if not is_checked:
+            state.name_widget.setText("")
+            state.frequency_widget.setValue(0)
+        self.check_validity()
+    def _is_scored_changed(self, digit: int, _state: int) -> None:
+        """Called when user sets whether a state is scored
+        :param digit: brain state digit
+        :param _state: unused but mandatory
+        """
+        state = self._settings_widgets[digit]
+        is_checked = state.is_scored_widget.isChecked()
+        state.frequency_widget.setEnabled(is_checked)
+        if not is_checked:
+            state.frequency_widget.setValue(0)
+        self.check_validity()
+    def _emg_filter_bp_lower_changed(self, _new_value: int | float) -> None:
+        """Called when user modifies EMG filter lower cutoff
+        Value is read from UI when config is saved. Triggers validation.
+        """
+        self.check_validity()
+    def _emg_filter_bp_upper_changed(self, _new_value: int | float) -> None:
+        """Called when user modifies EMG filter upper cutoff
+        Value is read from UI when config is saved. Triggers validation.
+        """
+        self.check_validity()
+    def _hyperparameters_changed(self, _new_value) -> None:
+        """Called when user modifies model training hyperparameters"""
+        # These are the only changes to the settings tab that take
+        # effect immediately
+        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(),
+        )
+        self._ui.save_config_status.setText("")
+    def reset_status_message(self, _new_value=None) -> None:
+        """Clear the message next to the 'save' button"""
+        self._ui.save_config_status.setText("")
+    def check_validity(self) -> str | None:
+        """Check if brain state configuration on screen is valid
+        :return: error message if invalid, None if valid
+        """
+        message = None
+        # Strip whitespace from brain state names and update display
+        for digit in range(10):
+            state = self._settings_widgets[digit]
+            current_name = state.name_widget.text()
+            formatted_name = current_name.strip()
+            if current_name != formatted_name:
+                state.name_widget.setText(formatted_name)
+        # Check if names are unique and frequencies add up to 1
+        names = []
+        frequencies = []
+        for digit in range(10):
+            state = self._settings_widgets[digit]
+            if state.enabled_widget.isChecked():
+                names.append(state.name_widget.text())
+                frequencies.append(state.frequency_widget.value())
+        if len(names) != len(set(names)):
+            message = "Error: names must be unique"
+        if sum(frequencies) != 1:
+            message = "Error: sum(frequencies) != 1"
+        # Check validity of EMG filter settings (read from UI, not saved state)
+        bp_lower = self._ui.bp_lower_spinbox.value()
+        bp_upper = self._ui.bp_upper_spinbox.value()
+        if bp_lower >= 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)
+            return message
+        self._ui.save_config_button.setEnabled(True)
+        self._ui.save_config_status.setText("")
+        return None
+    def save_config(self) -> None:
+        """Save configuration to file"""
+        # Check that configuration is valid
+        error_message = self.check_validity()
+        if error_message is not None:
+            return
+        # Build a BrainStateSet object from the current configuration
+        brain_states = []
+        for digit in range(10):
+            state = self._settings_widgets[digit]
+            if state.enabled_widget.isChecked():
+                brain_states.append(
+                    BrainState(
+                        name=state.name_widget.text(),
+                        digit=digit,
+                        is_scored=state.is_scored_widget.isChecked(),
+                        frequency=state.frequency_widget.value(),
+                    )
+                )
+        # Update brain state set and EMG filter from UI
+        # Note that this only occurs when a valid configuration is saved
+        self._brain_state_set = BrainStateSet(brain_states, UNDEFINED_LABEL)
+        self._emg_filter = EMGFilter(
+            order=self._ui.emg_order_spinbox.value(),
+            bp_lower=self._ui.bp_lower_spinbox.value(),
+            bp_upper=self._ui.bp_upper_spinbox.value(),
+        )
+        # Save to file
+        save_config(
+            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=self._emg_filter,
+            hyperparameters=self._hyperparameters,
+            epochs_to_show=self._ui.epochs_to_show_spinbox.value(),
+            autoscroll_state=self._ui.autoscroll_checkbox.isChecked(),
+        )
+        self._ui.save_config_status.setText("configuration saved")
+    def reset_emg_filter(self) -> None:
+        """Reset EMG filter settings to defaults"""
+        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(self) -> None:
+        """Reset hyperparameters to defaults"""
+        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)

accusleepy/gui/text/main_guide.md CHANGED Viewed

@@ -142,7 +142,7 @@ To train a new model on your own data:
     of the training data to set aside for calibration.
 7. Click "Train classification model" and enter a
     filename for the trained model. Training can take some time.
-    The console will display progress updates.
+    The terminal will display progress updates.
 ## 4C. Automatic scoring

accusleepy/models.py CHANGED Viewed

@@ -40,7 +40,7 @@ class SSANN(nn.Module):
 def save_model(
-    model: SSANN,
+    model: SSANN | ModelWithTemperature,
     filename: str,
     epoch_length: int | float,
     epochs_per_img: int,

accusleepy 0.8.0__py3-none-any.whl → 0.9.2__py3-none-any.whl

accusleepy 0.8.0py3-none-any.whl → 0.9.2py3-none-any.whl