coralnet-toolbox 0.0.69__tar.gz → 0.0.71__tar.gz

{coralnet_toolbox-0.0.69 → coralnet_toolbox-0.0.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coralnet-toolbox
-Version: 0.0.69
+Version: 0.0.71
 Summary: Tools for annotating and developing ML models for benthic imagery
 Author-email: Jordan Pierce <jordan.pierce@noaa.gov>
 License: MIT License
@@ -94,10 +94,12 @@ coralnet-toolbox
 
 ## 📚 Guides
 
-For further instructions please see the following guides:
+For further information and instructions, please see the following guides:
+- [Overview](https://jordan-pierce.github.io/CoralNet-Toolbox/overview)
 - [Installation](https://jordan-pierce.github.io/CoralNet-Toolbox/installation)
 - [Usage](https://jordan-pierce.github.io/CoralNet-Toolbox/usage)
-- [Patch-based Image Classifier](https://jordan-pierce.github.io/CoralNet-Toolbox/classify)
+- Community Provided:
+  - [Patch-based Image Classifier](https://jordan-pierce.github.io/CoralNet-Toolbox/classify)
 
 <details open>
   <summary><h2><b>🎥 Watch the Video Demos</b></h2></summary>
@@ -177,7 +179,7 @@ Enhance your CoralNet experience with these tools:
 - 🚀 Optimize: Productionize models for faster inferencing
 - ⚙️ Batch Inference: Perform predictions on multiple images, automatically
 - 🎞️ Video Inference: Perform predictions on a video in real-time, record the output and analytics
-- 🔮 Explorer: Cluster, view, and re-label annotations using embeddings, mapped from feature-space
+- 🔮 [Explorer](https://youtu.be/68eZt5l_7nA): Cluster, view, and re-label annotations using embeddings, mapped from feature-space
 - ↔️ I/O: Import and Export annotations from / to CoralNet, Viscore, and TagLab
   - Export annotations as [GeoJSONs](https://datatracker.ietf.org/doc/html/rfc7946), segmentation masks
 - 📸 YOLO: Import and Export YOLO datasets for machine learning

{coralnet_toolbox-0.0.69 → coralnet_toolbox-0.0.71}/README.md

@@ -50,10 +50,12 @@ coralnet-toolbox
 
 ## 📚 Guides
 
-For further instructions please see the following guides:
+For further information and instructions, please see the following guides:
+- [Overview](https://jordan-pierce.github.io/CoralNet-Toolbox/overview)
 - [Installation](https://jordan-pierce.github.io/CoralNet-Toolbox/installation)
 - [Usage](https://jordan-pierce.github.io/CoralNet-Toolbox/usage)
-- [Patch-based Image Classifier](https://jordan-pierce.github.io/CoralNet-Toolbox/classify)
+- Community Provided:
+  - [Patch-based Image Classifier](https://jordan-pierce.github.io/CoralNet-Toolbox/classify)
 
 <details open>
   <summary><h2><b>🎥 Watch the Video Demos</b></h2></summary>
@@ -133,7 +135,7 @@ Enhance your CoralNet experience with these tools:
 - 🚀 Optimize: Productionize models for faster inferencing
 - ⚙️ Batch Inference: Perform predictions on multiple images, automatically
 - 🎞️ Video Inference: Perform predictions on a video in real-time, record the output and analytics
-- 🔮 Explorer: Cluster, view, and re-label annotations using embeddings, mapped from feature-space
+- 🔮 [Explorer](https://youtu.be/68eZt5l_7nA): Cluster, view, and re-label annotations using embeddings, mapped from feature-space
 - ↔️ I/O: Import and Export annotations from / to CoralNet, Viscore, and TagLab
   - Export annotations as [GeoJSONs](https://datatracker.ietf.org/doc/html/rfc7946), segmentation masks
 - 📸 YOLO: Import and Export YOLO datasets for machine learning

{coralnet_toolbox-0.0.69 → coralnet_toolbox-0.0.71}/coralnet_toolbox/Annotations/QtAnnotation.py

@@ -262,7 +262,7 @@ class Annotation(QObject):
             # [1, 2] - Very small dots with small gaps
             # [2, 4] - Small dots with larger gaps
             # [1, 3] - Tiny dots with medium gaps
-            pen = QPen(pen_color, 3)  # Width for dotted line
+            pen = QPen(pen_color, 4)  # Width for dotted line
             pen.setStyle(Qt.CustomDashLine)
             pen.setDashPattern([1, 2])  # Dotted pattern: 2 pixels on, 3 pixels off
             pen.setDashOffset(self._animated_line)

{coralnet_toolbox-0.0.69 → coralnet_toolbox-0.0.71}/coralnet_toolbox/Explorer/QtExplorer.py

@@ -130,7 +130,7 @@ class EmbeddingViewer(QWidget):
         # Create a QToolButton to have both a primary action and a dropdown menu
         self.find_mislabels_button = QToolButton()
         self.find_mislabels_button.setText("Find Potential Mislabels")
-        self.find_mislabels_button.setPopupMode(QToolButton.MenuButtonPopup) # Key change for split-button style
+        self.find_mislabels_button.setPopupMode(QToolButton.MenuButtonPopup)  # Key change for split-button style
         self.find_mislabels_button.setToolButtonStyle(Qt.ToolButtonTextOnly)
         self.find_mislabels_button.setStyleSheet(
             "QToolButton::menu-indicator {"
@@ -186,9 +186,18 @@ class EmbeddingViewer(QWidget):
         
         uncertainty_settings_widget.parameters_changed.connect(self.uncertainty_parameters_changed.emit)
         toolbar_layout.addWidget(self.find_uncertain_button)
-
+    
+        # Add a strech and separator
         toolbar_layout.addStretch()
-        
+        toolbar_layout.addWidget(self._create_separator())
+
+        # Center on selection button
+        self.center_on_selection_button = QPushButton()
+        self.center_on_selection_button.setIcon(get_icon("target.png"))
+        self.center_on_selection_button.setToolTip("Center view on selected point(s)")
+        self.center_on_selection_button.clicked.connect(self.center_on_selection)
+        toolbar_layout.addWidget(self.center_on_selection_button)
+                
         # Home button to reset view
         self.home_button = QPushButton()
         self.home_button.setIcon(get_icon("home.png"))
@@ -258,6 +267,7 @@ class EmbeddingViewer(QWidget):
 
         self.find_mislabels_button.setEnabled(points_exist)
         self.find_uncertain_button.setEnabled(points_exist and self.is_uncertainty_analysis_available)
+        self.center_on_selection_button.setEnabled(points_exist and selection_exists)
 
         if self.isolated_mode:
             self.isolate_button.hide()
@@ -270,12 +280,46 @@ class EmbeddingViewer(QWidget):
     def reset_view(self):
         """Reset the view to fit all embedding points."""
         self.fit_view_to_points()
+        
+    def center_on_selection(self):
+        """Centers the view on selected point(s) or maintains the current view if no points are selected."""
+        selected_items = self.graphics_scene.selectedItems()
+        if not selected_items:
+            # No selection, show a message
+            QMessageBox.information(self, "No Selection", "Please select one or more points first.")
+            return
+            
+        # Create a bounding rect that encompasses all selected points
+        selection_rect = None
+        
+        for item in selected_items:
+            if isinstance(item, EmbeddingPointItem):
+                # Get the item's bounding rect in scene coordinates
+                item_rect = item.sceneBoundingRect()
+                
+                # Add padding around the point for better visibility
+                padding = 50  # pixels
+                item_rect = item_rect.adjusted(-padding, -padding, padding, padding)
+                
+                if selection_rect is None:
+                    selection_rect = item_rect
+                else:
+                    selection_rect = selection_rect.united(item_rect)
+        
+        if selection_rect:
+            # Add extra margin for better visibility
+            margin = 20
+            selection_rect = selection_rect.adjusted(-margin, -margin, margin, margin)
+            
+            # Fit the view to the selection rect
+            self.graphics_view.fitInView(selection_rect, Qt.KeepAspectRatio)
 
     def show_placeholder(self):
         """Show the placeholder message and hide the graphics view."""
         self.graphics_view.setVisible(False)
         self.placeholder_label.setVisible(True)
         self.home_button.setEnabled(False)
+        self.center_on_selection_button.setEnabled(False)  # Disable center button
         self.find_mislabels_button.setEnabled(False)
         self.find_uncertain_button.setEnabled(False)
 
@@ -346,6 +390,39 @@ class EmbeddingViewer(QWidget):
 
     def mousePressEvent(self, event):
         """Handle mouse press for selection (point or rubber band) and panning."""
+        # Ctrl+Right-Click for context menu selection 
+        if event.button() == Qt.RightButton and event.modifiers() == Qt.ControlModifier:
+            item_at_pos = self.graphics_view.itemAt(event.pos())
+            if isinstance(item_at_pos, EmbeddingPointItem):
+                # 1. Clear all selections in both viewers
+                self.graphics_scene.clearSelection()
+                item_at_pos.setSelected(True)
+                self.on_selection_changed()  # Updates internal state and emits signals
+
+                # 2. Sync annotation viewer selection
+                ann_id = item_at_pos.data_item.annotation.id
+                self.explorer_window.annotation_viewer.render_selection_from_ids({ann_id})
+
+                # 3. Update annotation window (set image, select, center)
+                explorer = self.explorer_window
+                annotation = item_at_pos.data_item.annotation
+                image_path = annotation.image_path
+
+                if hasattr(explorer, 'annotation_window'):
+                    if explorer.annotation_window.current_image_path != image_path:
+                        if hasattr(explorer.annotation_window, 'set_image'):
+                            explorer.annotation_window.set_image(image_path)
+                    if hasattr(explorer.annotation_window, 'select_annotation'):
+                        explorer.annotation_window.select_annotation(annotation)
+                    if hasattr(explorer.annotation_window, 'center_on_annotation'):
+                        explorer.annotation_window.center_on_annotation(annotation)
+
+                explorer.update_label_window_selection()
+                explorer.update_button_states()
+                event.accept()
+                return
+
+        # Handle left-click for selection or rubber band
         if event.button() == Qt.LeftButton and event.modifiers() == Qt.ControlModifier:
             item_at_pos = self.graphics_view.itemAt(event.pos())
             if isinstance(item_at_pos, EmbeddingPointItem):
@@ -701,6 +778,14 @@ class AnnotationViewer(QScrollArea):
             explorer = self.explorer_window
             image_path = widget.annotation.image_path
             annotation_to_select = widget.annotation
+        
+            # ctrl+right click to only select this annotation (single selection):
+            self.clear_selection()
+            self.select_widget(widget)
+            changed_ids = [widget.data_item.annotation.id]
+
+            if changed_ids:
+                self.selection_changed.emit(changed_ids)
 
             if hasattr(explorer, 'annotation_window'):
                 # Check if the image needs to be changed
@@ -710,15 +795,17 @@ class AnnotationViewer(QScrollArea):
 
                 # Now, select the annotation in the annotation_window
                 if hasattr(explorer.annotation_window, 'select_annotation'):
-                    # This method by default unselects other annotations
                     explorer.annotation_window.select_annotation(annotation_to_select)
+                    
+                # Center the annotation window view on the selected annotation
+                if hasattr(explorer.annotation_window, 'center_on_annotation'):
+                    explorer.annotation_window.center_on_annotation(annotation_to_select)
 
                 # Also clear any existing selection in the explorer window itself
-                explorer.annotation_viewer.clear_selection()
-                explorer.embedding_viewer.render_selection_from_ids(set())
+                explorer.embedding_viewer.render_selection_from_ids({widget.data_item.annotation.id})
                 explorer.update_label_window_selection()
                 explorer.update_button_states()
-
+            
             event.accept()
 
     @pyqtSlot()
@@ -982,6 +1069,8 @@ class AnnotationViewer(QScrollArea):
 
         self.recalculate_widget_positions()
         self._update_toolbar_state()
+        # Update the label window with the new annotation count
+        self.explorer_window.main_window.label_window.update_annotation_count()
 
     def resizeEvent(self, event):
         """On window resize, reflow the annotation widgets."""
@@ -1027,11 +1116,17 @@ class AnnotationViewer(QScrollArea):
                             break
                         widget = widget.parent()
 
-                # If click is outside widgets and there is a selection, clear it
-                if not is_on_widget and self.selected_widgets:
-                    changed_ids = [w.data_item.annotation.id for w in self.selected_widgets]
-                    self.clear_selection()
-                    self.selection_changed.emit(changed_ids)
+                # If click is outside widgets, clear annotation_window selection
+                if not is_on_widget:
+                    # Clear annotation selection in the annotation_window as well
+                    if hasattr(self.explorer_window, 'annotation_window') and self.explorer_window.annotation_window:
+                        if hasattr(self.explorer_window.annotation_window, 'unselect_annotations'):
+                            self.explorer_window.annotation_window.unselect_annotations()
+                    # If there is a selection in the viewer, clear it
+                    if self.selected_widgets:
+                        changed_ids = [w.data_item.annotation.id for w in self.selected_widgets]
+                        self.clear_selection()
+                        self.selection_changed.emit(changed_ids)
                     return
 
             elif event.modifiers() == Qt.ControlModifier:
@@ -1371,6 +1466,7 @@ class ExplorerWindow(QMainWindow):
 
         self.device = main_window.device
         self.loaded_model = None
+        self.loaded_model_imgsz = 128
 
         self.feature_store = FeatureStore()
         
@@ -1724,13 +1820,15 @@ class ExplorerWindow(QMainWindow):
         """
         Identifies annotations whose label does not match the majority of its
         k-nearest neighbors in the high-dimensional feature space.
+        Skips any annotation or neighbor with an invalid label (id == -1).
         """
         # Get parameters from the stored property instead of hardcoding
         K = self.mislabel_params.get('k', 5)
         agreement_threshold = self.mislabel_params.get('threshold', 0.6)
 
         if not self.embedding_viewer.points_by_id or len(self.embedding_viewer.points_by_id) < K:
-            QMessageBox.information(self, "Not Enough Data",
+            QMessageBox.information(self, 
+                                    "Not Enough Data",
                                     f"This feature requires at least {K} points in the embedding viewer.")
             return
 
@@ -1741,7 +1839,6 @@ class ExplorerWindow(QMainWindow):
         model_info = self.model_settings_widget.get_selected_model()
         model_name, feature_mode = model_info if isinstance(model_info, tuple) else (model_info, "default")
         sanitized_model_name = os.path.basename(model_name).replace(' ', '_')
-        # FIX: Also replace the forward slash to handle "N/A"
         sanitized_feature_mode = feature_mode.replace(' ', '_').replace('/', '_')
         model_key = f"{sanitized_model_name}_{sanitized_feature_mode}"
 
@@ -1751,13 +1848,17 @@ class ExplorerWindow(QMainWindow):
             index = self.feature_store._get_or_load_index(model_key)
             faiss_idx_to_ann_id = self.feature_store.get_faiss_index_to_annotation_id_map(model_key)
             if index is None or not faiss_idx_to_ann_id:
-                QMessageBox.warning(self, "Error", "Could not find a valid feature index for the current model.")
+                QMessageBox.warning(self, 
+                                    "Error", 
+                                    "Could not find a valid feature index for the current model.")
                 return
 
             # Get the high-dimensional features for the points in the current view
             features_dict, _ = self.feature_store.get_features(data_items_in_view, model_key)
             if not features_dict:
-                QMessageBox.warning(self, "Error", "Could not retrieve features for the items in view.")
+                QMessageBox.warning(self, 
+                                    "Error", 
+                                    "Could not retrieve features for the items in view.")
                 return
 
             query_ann_ids = list(features_dict.keys())
@@ -1768,25 +1869,33 @@ class ExplorerWindow(QMainWindow):
 
             mislabeled_ann_ids = []
             for i, ann_id in enumerate(query_ann_ids):
-                current_label = self.data_item_cache[ann_id].effective_label.id
-                
+                data_item = self.data_item_cache[ann_id]
+                # Use preview_label if present, else effective_label
+                label_obj = getattr(data_item, "preview_label", None) or data_item.effective_label
+                current_label_id = getattr(label_obj, "id", "-1")
+                if current_label_id == "-1":
+                    continue  # Skip if label is invalid
+
                 # Get neighbor labels, ignoring the first result (the point itself)
                 neighbor_faiss_indices = I[i][1:]
-                
+
                 neighbor_labels = []
                 for n_idx in neighbor_faiss_indices:
-                    # THIS IS THE CORRECTED LOGIC
                     if n_idx in faiss_idx_to_ann_id:
                         neighbor_ann_id = faiss_idx_to_ann_id[n_idx]
-                        # ADD THIS CHECK to ensure the neighbor hasn't been deleted
                         if neighbor_ann_id in self.data_item_cache:
-                            neighbor_labels.append(self.data_item_cache[neighbor_ann_id].effective_label.id)
+                            neighbor_item = self.data_item_cache[neighbor_ann_id]
+                            neighbor_label_obj = getattr(neighbor_item, "preview_label", None)
+                            if neighbor_label_obj is None:
+                                neighbor_label_obj = neighbor_item.effective_label
+                            neighbor_label_id = getattr(neighbor_label_obj, "id", "-1")
+                            if neighbor_label_id != "-1":
+                                neighbor_labels.append(neighbor_label_id)
 
                 if not neighbor_labels:
                     continue
 
-                # Use the agreement threshold instead of strict majority
-                num_matching_neighbors = neighbor_labels.count(current_label)
+                num_matching_neighbors = neighbor_labels.count(current_label_id)
                 agreement_ratio = num_matching_neighbors / len(neighbor_labels)
 
                 if agreement_ratio < agreement_threshold:
@@ -2031,16 +2140,36 @@ class ExplorerWindow(QMainWindow):
             print(f"Model or mode changed. Reloading {model_name} for '{feature_mode}'.")
             try:
                 model = YOLO(model_name)
+                
+                # Check if the model task is compatible with the selected feature mode
+                if model.task != 'classify' and feature_mode == "Predictions":
+                    QMessageBox.warning(self, 
+                                        "Invalid Mode for Model",
+                                        f"The selected model is a '{model.task}' model. "
+                                        "The 'Predictions' feature mode is only available for 'classify' models. "
+                                        "Reverting to 'Embed Features' mode.")
+
+                    # Force the feature mode combo box back to "Embed Features"
+                    self.model_settings_widget.feature_mode_combo.setCurrentText("Embed Features")
+                    
+                    # On failure, reset the model cache
+                    self.loaded_model = None
+                    self.current_feature_generating_model = None
+                    return None, None
+
                 # Update the cache key to the new successful combination
                 self.current_feature_generating_model = current_run_key
                 self.loaded_model = model
-                imgsz = getattr(model.model.args, 'imgsz', 128)
+                
+                # Get the imgsz, but if it's larger than 128, default to 128
+                imgsz = min(getattr(model.model.args, 'imgsz', 128), 128)
+                self.loaded_model_imgsz = imgsz
                 
                 # Warm up the model
                 dummy_image = np.zeros((imgsz, imgsz, 3), dtype=np.uint8)
                 model.predict(dummy_image, imgsz=imgsz, half=True, device=self.device, verbose=False)
                 
-                return model, imgsz
+                return model, self.loaded_model_imgsz
                 
             except Exception as e:
                 print(f"ERROR: Could not load YOLO model '{model_name}': {e}")
@@ -2049,8 +2178,8 @@ class ExplorerWindow(QMainWindow):
                 self.current_feature_generating_model = None
                 return None, None
         
-        # Model already loaded and cached
-        return self.loaded_model, getattr(self.loaded_model.model.args, 'imgsz', 128)
+        # Model already loaded and cached, return it and its image size
+        return self.loaded_model, self.loaded_model_imgsz
 
     def _prepare_images_from_data_items(self, data_items, progress_bar=None):
         """
@@ -2488,6 +2617,10 @@ class ExplorerWindow(QMainWindow):
             # Reset sort options when filters change
             self.annotation_viewer.active_ordered_ids = []
             self.annotation_viewer.set_confidence_sort_availability(False)
+            
+            # Update the annotation count in the label window
+            self.label_window.update_annotation_count()
+
         finally:
             QApplication.restoreOverrideCursor()
 

{coralnet_toolbox-0.0.69 → coralnet_toolbox-0.0.71}/coralnet_toolbox/MachineLearning/TrainModel/QtBase.py

@@ -660,6 +660,10 @@ class Base(QDialog):
                 QMessageBox.warning(self, "Import Warning", "The YAML file appears to be empty or invalid.")
                 return
 
+            # For backward compatibility, check if the old nested 'parameters' key exists.
+            # If not, use the whole data dictionary.
+            params_to_load = data.get('parameters', data)
+
             # Helper function to infer type from value
             def infer_type_and_value(value):
                 """
@@ -673,12 +677,9 @@ class Base(QDialog):
                 elif isinstance(value, float):
                     return "float", value
                 elif isinstance(value, str):
-                    # Check for boolean strings
                     if value.lower() in ['true', 'false']:
                         return "bool", value.lower() == 'true'
-                    # Check for numeric strings
                     try:
-                        # Try to convert to int first
                         if '.' not in value:
                             return "int", int(value)
                         else:
@@ -686,14 +687,13 @@ class Base(QDialog):
                     except ValueError:
                         return "string", value
                 else:
-                    # For any other type, convert to string
                     return "string", str(value)
 
             # Clear existing custom parameters before importing
             while self.custom_params:
                 self.remove_parameter_pair()
 
-            # Map parameters to UI controls
+            # Map standard parameters to their UI controls
             param_mapping = {
                 'epochs': self.epochs_spinbox,
                 'patience': self.patience_spinbox,
@@ -712,37 +712,31 @@ class Base(QDialog):
             }
 
             # Update UI controls with imported values
-            for param_name, value in data.items():
+            for param_name, value in params_to_load.items():
                 param_type, converted_value = infer_type_and_value(value)
                 
                 if param_name in param_mapping:
                     widget = param_mapping[param_name]
                     
                     if isinstance(widget, QSpinBox):
-                        if param_type in ['int', 'float'] and isinstance(converted_value, (int, float)):
+                        if isinstance(converted_value, (int, float)):
                             widget.setValue(int(converted_value))
                     elif isinstance(widget, QDoubleSpinBox):
-                        if param_type in ['int', 'float'] and isinstance(converted_value, (int, float)):
+                        if isinstance(converted_value, (int, float)):
                             widget.setValue(float(converted_value))
                     elif isinstance(widget, QComboBox):
                         if param_name in ['multi_scale', 'save', 'weighted', 'val', 'verbose']:
-                            # Boolean parameters
-                            if param_type == 'bool':
-                                widget.setCurrentText("True" if converted_value else "False")
-                        else:
-                            # String parameters like optimizer
-                            if str(converted_value) in [widget.itemText(i) for i in range(widget.count())]:
-                                widget.setCurrentText(str(converted_value))
+                            widget.setCurrentText("True" if converted_value else "False")
+                        elif str(converted_value) in [widget.itemText(i) for i in range(widget.count())]:
+                            widget.setCurrentText(str(converted_value))
                 else:
-                    # Add as custom parameter using inferred type
+                    # Add as a custom parameter
                     self.add_parameter_pair()
-                    param_widgets = self.custom_params[-1]
-                    param_name_widget, param_value_widget, param_type_widget = param_widgets
+                    param_name_widget, param_value_widget, param_type_widget = self.custom_params[-1]
                     
                     param_name_widget.setText(param_name)
                     param_type_widget.setCurrentText(param_type)
                     
-                    # Set value based on type
                     if param_type == "bool":
                         param_value_widget.setText("True" if converted_value else "False")
                     else:
@@ -750,14 +744,14 @@ class Base(QDialog):
 
             QMessageBox.information(self, 
                                     "Import Success", 
-                                    "Parameters successfully imported with automatic type inference")
+                                    "Parameters successfully imported with automatic type inference.")
 
         except Exception as e:
             QMessageBox.critical(self, "Import Error", f"Failed to import parameters: {str(e)}")
 
     def export_parameters(self):
         """
-        Export current parameters to a YAML file with explicit type information.
+        Export current parameters to a flat YAML file.
         """
         file_path, _ = QFileDialog.getSaveFileName(self,
                                                    "Export Parameters to YAML",
@@ -767,69 +761,56 @@ class Base(QDialog):
             return
 
         try:
-            # Structure: types section followed by parameters section
-            export_data = {
-                'types': {},
-                'parameters': {}
-            }
-            
-            # Standard parameters with their types
-            standard_params = {
-                'epochs': ('int', self.epochs_spinbox.value()),
-                'patience': ('int', self.patience_spinbox.value()),
-                'imgsz': ('int', self.imgsz_spinbox.value()),
-                'batch': ('int', self.batch_spinbox.value()),
-                'workers': ('int', self.workers_spinbox.value()),
-                'save_period': ('int', self.save_period_spinbox.value()),
-                'freeze_layers': ('float', self.freeze_layers_spinbox.value()),
-                'dropout': ('float', self.dropout_spinbox.value()),
-                'multi_scale': ('bool', self.multi_scale_combo.currentText() == "True"),
-                'save': ('bool', self.save_combo.currentText() == "True"),
-                'weighted': ('bool', self.weighted_combo.currentText() == "True"),
-                'val': ('bool', self.val_combo.currentText() == "True"),
-                'verbose': ('bool', self.verbose_combo.currentText() == "True"),
-                'optimizer': ('string', self.optimizer_combo.currentText())
-            }
-
-            # Add standard parameters
-            for param_name, (param_type, value) in standard_params.items():
-                export_data['types'][param_name] = param_type
-                export_data['parameters'][param_name] = value
+            # Use a single flat dictionary for export
+            export_data = {}
+
+            # Standard parameters
+            export_data['epochs'] = self.epochs_spinbox.value()
+            export_data['patience'] = self.patience_spinbox.value()
+            export_data['imgsz'] = self.imgsz_spinbox.value()
+            export_data['batch'] = self.batch_spinbox.value()
+            export_data['workers'] = self.workers_spinbox.value()
+            export_data['save_period'] = self.save_period_spinbox.value()
+            export_data['freeze_layers'] = self.freeze_layers_spinbox.value()
+            export_data['dropout'] = self.dropout_spinbox.value()
+            export_data['multi_scale'] = self.multi_scale_combo.currentText() == "True"
+            export_data['save'] = self.save_combo.currentText() == "True"
+            export_data['weighted'] = self.weighted_combo.currentText() == "True"
+            export_data['val'] = self.val_combo.currentText() == "True"
+            export_data['verbose'] = self.verbose_combo.currentText() == "True"
+            export_data['optimizer'] = self.optimizer_combo.currentText()
 
             # Custom parameters
             for param_info in self.custom_params:
-                param_name, param_value, param_type = param_info
-                name = param_name.text().strip()
-                value = param_value.text().strip()
-                type_name = param_type.currentText()
+                param_name_widget, param_value_widget, param_type_widget = param_info
+                name = param_name_widget.text().strip()
+                value_str = param_value_widget.text().strip()
+                type_name = param_type_widget.currentText()
                 
-                if name and value:
-                    export_data['types'][name] = type_name
-                    
-                    if type_name == "bool":
-                        export_data['parameters'][name] = value.lower() == "true"
-                    elif type_name == "int":
-                        try:
-                            export_data['parameters'][name] = int(value)
-                        except ValueError:
-                            export_data['parameters'][name] = value
-                            export_data['types'][name] = "string"  # Fallback to string
-                    elif type_name == "float":
-                        try:
-                            export_data['parameters'][name] = float(value)
-                        except ValueError:
-                            export_data['parameters'][name] = value
-                            export_data['types'][name] = "string"  # Fallback to string
-                    else:  # string type
-                        export_data['parameters'][name] = value
-
-            # Write to YAML file
+                if name and value_str:
+                    # Convert value to the correct type before exporting
+                    try:
+                        if type_name == "bool":
+                            value = value_str.lower() == "true"
+                        elif type_name == "int":
+                            value = int(value_str)
+                        elif type_name == "float":
+                            value = float(value_str)
+                        else:  # string type
+                            value = value_str
+                        export_data[name] = value
+                    except ValueError:
+                        # If conversion fails, save it as a string
+                        print(f"Warning: Could not convert '{value_str}' to {type_name} for parameter '{name}'. Saving as string.")
+                        export_data[name] = value_str
+
+            # Write the flat dictionary to the YAML file
             with open(file_path, 'w') as f:
-                yaml.dump(export_data, f, default_flow_style=False, indent=2)
+                yaml.dump(export_data, f, default_flow_style=False, sort_keys=False, indent=2)
 
             QMessageBox.information(self, 
                                     "Export Success", 
-                                    "Parameters successfully exported")
+                                    "Parameters successfully exported.")
 
         except Exception as e:
             QMessageBox.critical(self,